pax_global_header00006660000000000000000000000064136624255020014517gustar00rootroot0000000000000052 comment=8fc7f10e8d3c9da78fa7cabd585139ad05e141b9 Fairy-Stockfish-fairy_sf_11_1/000077500000000000000000000000001366242550200164115ustar00rootroot00000000000000Fairy-Stockfish-fairy_sf_11_1/.gitignore000066400000000000000000000000261366242550200203770ustar00rootroot00000000000000stockfish *.o .depend Fairy-Stockfish-fairy_sf_11_1/.travis.yml000066400000000000000000000055441366242550200205320ustar00rootroot00000000000000language: cpp dist: xenial matrix: include: - os: linux compiler: gcc addons: apt: sources: ['ubuntu-toolchain-r-test'] packages: ['g++-8', 'g++-8-multilib', 'g++-multilib', 'valgrind', 'expect', 'curl'] env: - COMPILER=g++-8 - COMP=gcc - os: linux compiler: clang addons: apt: sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-xenial-6.0'] packages: ['clang-6.0', 'llvm-6.0-dev', 'g++-multilib', 'valgrind', 'expect', 'curl'] env: - COMPILER=clang++-6.0 - COMP=clang - LDFLAGS=-fuse-ld=lld - os: osx compiler: gcc env: - COMPILER=g++ - COMP=gcc - os: osx compiler: clang env: - COMPILER=clang++ V='Apple LLVM 9.4.1' # Apple LLVM version 9.1.0 (clang-902.0.39.2) - COMP=clang before_script: - cd src script: # Check perft of large-board version - make clean && make -j2 ARCH=x86-64 largeboards=yes debug=yes build && ../tests/perft.sh largeboard - ./stockfish bench xiangqi > /dev/null 2>&1 - ./stockfish bench shogi > /dev/null 2>&1 - ./stockfish bench capablanca > /dev/null 2>&1 - ./stockfish bench sittuyin > /dev/null 2>&1 - make clean && make -j2 ARCH=x86-32 largeboards=yes debug=yes build && ../tests/perft.sh largeboard # # Obtain bench reference from git log - git log HEAD | grep "\b[Bb]ench[ :]\+[0-9]\{7\}" | head -n 1 | sed "s/[^0-9]*\([0-9]*\).*/\1/g" > git_sig - export benchref=$(cat git_sig) - echo "Reference bench:" $benchref # # Verify bench number against various builds - export CXXFLAGS=-Werror - make clean && make -j2 ARCH=x86-64 optimize=no debug=yes build && ../tests/signature.sh $benchref - make clean && make -j2 ARCH=x86-32 optimize=no debug=yes build && ../tests/signature.sh $benchref - make clean && make -j2 ARCH=x86-32 build && ../tests/signature.sh $benchref # # Check perft and reproducible search - ../tests/protocol.sh - ../tests/perft.sh - ../tests/reprosearch.sh # # Valgrind # - export CXXFLAGS="-O1 -fno-inline" - if [ -x "$(command -v valgrind )" ]; then make clean && make -j2 ARCH=x86-64 debug=yes optimize=no build > /dev/null && ../tests/instrumented.sh --valgrind; fi - if [ -x "$(command -v valgrind )" ]; then ../tests/instrumented.sh --valgrind-thread; fi # # Sanitizer # # Use g++-8 as a proxy for having sanitizers, might need revision as they become available for more recent versions of clang/gcc - if [[ "$COMPILER" == "g++-8" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=undefined optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-undefined; fi - if [[ "$COMPILER" == "g++-8" ]]; then make clean && make -j2 ARCH=x86-64 sanitize=thread optimize=no debug=yes build > /dev/null && ../tests/instrumented.sh --sanitizer-thread; fi Fairy-Stockfish-fairy_sf_11_1/AUTHORS000066400000000000000000000067541366242550200174750ustar00rootroot00000000000000# List of authors for Stockfish, as of January 7, 2020 Tord Romstad (romstad) Marco Costalba (mcostalba) Joona Kiiski (zamar) Gary Linscott (glinscott) Aditya (absimaldata) Adrian Petrescu (apetresc) Ajith Chandy Jose (ajithcj) Alain Savard (Rocky640) Alayan Feh (Alayan-stk-2) Alexander Kure Alexander Pagel (Lolligerhans) Ali AlZhrani (Cooffe) Andrew Grant (AndyGrant) Andrey Neporada (nepal) Andy Duplain Aram Tumanian (atumanian) Arjun Temurnikar Auguste Pop Balint Pfliegel Ben Koshy (BKSpurgeon) Bill Henry (VoyagerOne) Bojun Guo (noobpwnftw, Nooby) braich Brian Sheppard (SapphireBrand, briansheppard-toast) Bryan Cross (crossbr) candirufish Chess13234 Chris Cain (ceebo) Dan Schmidt (dfannius) Daniel Axtens (daxtens) Daniel Dugovic (ddugovic) Dariusz Orzechowski David Zar Daylen Yang (daylen) DiscanX double-beep Eduardo Cáceres (eduherminio) Eelco de Groot (KingDefender) Elvin Liu (solarlight2) erbsenzaehler Ernesto Gatti Fabian Beuke (madnight) Fabian Fichter (ianfab) fanon Fauzi Akram Dabat (FauziAkram) Felix Wittmann gamander gguliash Gian-Carlo Pascutto (gcp) Gontran Lemaire (gonlem) Goodkov Vasiliy Aleksandrovich (goodkov) Gregor Cramer GuardianRM Günther Demetz (pb00067, pb00068) Guy Vreuls (gvreuls) Henri Wiechers Hiraoka Takuya (HiraokaTakuya) homoSapiensSapiens Hongzhi Cheng Ivan Ivec (IIvec) Jacques B. (Timshel) Jan Ondruš (hxim) Jared Kish (Kurtbusch) Jarrod Torriero (DU-jdto) Jean Gauthier (OuaisBla) Jean-Francois Romang (jromang) Jekaa Jerry Donald Watson (jerrydonaldwatson) Jonathan Calovski (Mysseno) Jonathan Dumale (SFisGOD) Joost VandeVondele (vondele) Jörg Oster (joergoster) Joseph Ellis (jhellis3) Joseph R. Prostko jundery Justin Blanchard (UncombedCoconut) Kelly Wilson Ken Takusagawa kinderchocolate Kiran Panditrao (Krgp) Kojirion Leonardo Ljubičić (ICCF World Champion) Leonid Pechenik (lp--) Linus Arver (listx) loco-loco Lub van den Berg (ElbertoOne) Luca Brivio (lucabrivio) Lucas Braesch (lucasart) Lyudmil Antonov (lantonov) Maciej Żenczykowski (zenczykowski) Malcolm Campbell (xoto10) Mark Tenzer (31m059) marotear Matthew Lai (matthewlai) Matthew Sullivan (Matt14916) Michael An (man) Michael Byrne (MichaelB7) Michael Chaly (Vizvezdenec) Michael Stembera (mstembera) Michael Whiteley (protonspring) Michel Van den Bergh (vdbergh) Miguel Lahoz (miguel-l) Mikael Bäckman (mbootsector) Mira Miroslav Fontán (Hexik) Moez Jellouli (MJZ1977) Mohammed Li (tthsqe12) Nathan Rugg (nmrugg) Nick Pelling (nickpelling) Nicklas Persson (NicklasPersson) Niklas Fiekas (niklasf) Nikolay Kostov (NikolayIT) Ondrej Mosnáček (WOnder93) Oskar Werkelin Ahlin Pablo Vazquez Panthee Pascal Romaret Pasquale Pigazzini (ppigazzini) Patrick Jansen (mibere) pellanda Peter Zsifkovits (CoffeeOne) Ralph Stößer (Ralph Stoesser) Raminder Singh renouve Reuven Peleg Richard Lloyd Rodrigo Exterckötter Tjäder Ron Britvich (Britvich) Ronald de Man (syzygy1, syzygy) Ryan Schmitt Ryan Takker Sami Kiminki (skiminki) Sebastian Buchwald (UniQP) Sergei Antonov (saproj) Sergei Ivanov (svivanov72) sf-x Shane Booth (shane31) Stefan Geschwentner (locutus2) Stefano Cardanobile (Stefano80) Steinar Gunderson (sesse) Stéphane Nicolet (snicolet) Thanar2 thaspel theo77186 Tom Truscott Tom Vijlbrief (tomtor) Torsten Franz (torfranz, tfranzer) Tracey Emery (basepr1me) Uri Blass (uriblass) Vince Negri (cuddlestmonkey) # Additionally, we acknowledge the authors and maintainers of fishtest, # an amazing and essential framework for the development of Stockfish! # # https://github.com/glinscott/fishtest/blob/master/AUTHORS Fairy-Stockfish-fairy_sf_11_1/Copying.txt000066400000000000000000001057551366242550200205770ustar00rootroot00000000000000 GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The GNU General Public License is a free, copyleft license for software and other kinds of works. The licenses for most software and other practical works are designed to take away your freedom to share and change the works. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change all versions of a program--to make sure it remains free software for all its users. We, the Free Software Foundation, use the GNU General Public License for most of our software; it applies also to any other work released this way by its authors. You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for them if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs, and that you know you can do these things. To protect your rights, we need to prevent others from denying you these rights or asking you to surrender the rights. Therefore, you have certain responsibilities if you distribute copies of the software, or if you modify it: responsibilities to respect the freedom of others. For example, if you distribute copies of such a program, whether gratis or for a fee, you must pass on to the recipients the same freedoms that you received. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. Developers that use the GNU GPL protect your rights with two steps: (1) assert copyright on the software, and (2) offer you this License giving you legal permission to copy, distribute and/or modify it. For the developers' and authors' protection, the GPL clearly explains that there is no warranty for this free software. For both users' and authors' sake, the GPL requires that modified versions be marked as changed, so that their problems will not be attributed erroneously to authors of previous versions. Some devices are designed to deny users access to install or run modified versions of the software inside them, although the manufacturer can do so. This is fundamentally incompatible with the aim of protecting users' freedom to change the software. The systematic pattern of such abuse occurs in the area of products for individuals to use, which is precisely where it is most unacceptable. Therefore, we have designed this version of the GPL to prohibit the practice for those products. If such problems arise substantially in other domains, we stand ready to extend this provision to those domains in future versions of the GPL, as needed to protect the freedom of users. Finally, every program is threatened constantly by software patents. States should not allow patents to restrict development and use of software on general-purpose computers, but in those that do, we wish to avoid the special danger that patents applied to a free program could make it effectively proprietary. To prevent this, the GPL assures that patents cannot be used to render the program non-free. The precise terms and conditions for copying, distribution and modification follow. TERMS AND CONDITIONS 0. Definitions. "This License" refers to version 3 of the GNU General Public License. "Copyright" also means copyright-like laws that apply to other kinds of works, such as semiconductor masks. "The Program" refers to any copyrightable work licensed under this License. Each licensee is addressed as "you". "Licensees" and "recipients" may be individuals or organizations. To "modify" a work means to copy from or adapt all or part of the work in a fashion requiring copyright permission, other than the making of an exact copy. The resulting work is called a "modified version" of the earlier work or a work "based on" the earlier work. A "covered work" means either the unmodified Program or a work based on the Program. To "propagate" a work means to do anything with it that, without permission, would make you directly or secondarily liable for infringement under applicable copyright law, except executing it on a computer or modifying a private copy. Propagation includes copying, distribution (with or without modification), making available to the public, and in some countries other activities as well. To "convey" a work means any kind of propagation that enables other parties to make or receive copies. Mere interaction with a user through a computer network, with no transfer of a copy, is not conveying. An interactive user interface displays "Appropriate Legal Notices" to the extent that it includes a convenient and prominently visible feature that (1) displays an appropriate copyright notice, and (2) tells the user that there is no warranty for the work (except to the extent that warranties are provided), that licensees may convey the work under this License, and how to view a copy of this License. If the interface presents a list of user commands or options, such as a menu, a prominent item in the list meets this criterion. 1. Source Code. The "source code" for a work means the preferred form of the work for making modifications to it. "Object code" means any non-source form of a work. A "Standard Interface" means an interface that either is an official standard defined by a recognized standards body, or, in the case of interfaces specified for a particular programming language, one that is widely used among developers working in that language. The "System Libraries" of an executable work include anything, other than the work as a whole, that (a) is included in the normal form of packaging a Major Component, but which is not part of that Major Component, and (b) serves only to enable use of the work with that Major Component, or to implement a Standard Interface for which an implementation is available to the public in source code form. A "Major Component", in this context, means a major essential component (kernel, window system, and so on) of the specific operating system (if any) on which the executable work runs, or a compiler used to produce the work, or an object code interpreter used to run it. The "Corresponding Source" for a work in object code form means all the source code needed to generate, install, and (for an executable work) run the object code and to modify the work, including scripts to control those activities. However, it does not include the work's System Libraries, or general-purpose tools or generally available free programs which are used unmodified in performing those activities but which are not part of the work. For example, Corresponding Source includes interface definition files associated with source files for the work, and the source code for shared libraries and dynamically linked subprograms that the work is specifically designed to require, such as by intimate data communication or control flow between those subprograms and other parts of the work. The Corresponding Source need not include anything that users can regenerate automatically from other parts of the Corresponding Source. The Corresponding Source for a work in source code form is that same work. 2. Basic Permissions. All rights granted under this License are granted for the term of copyright on the Program, and are irrevocable provided the stated conditions are met. This License explicitly affirms your unlimited permission to run the unmodified Program. The output from running a covered work is covered by this License only if the output, given its content, constitutes a covered work. This License acknowledges your rights of fair use or other equivalent, as provided by copyright law. You may make, run and propagate covered works that you do not convey, without conditions so long as your license otherwise remains in force. You may convey covered works to others for the sole purpose of having them make modifications exclusively for you, or provide you with facilities for running those works, provided that you comply with the terms of this License in conveying all material for which you do not control copyright. Those thus making or running the covered works for you must do so exclusively on your behalf, under your direction and control, on terms that prohibit them from making any copies of your copyrighted material outside their relationship with you. Conveying under any other circumstances is permitted solely under the conditions stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 3. Protecting Users' Legal Rights From Anti-Circumvention Law. No covered work shall be deemed part of an effective technological measure under any applicable law fulfilling obligations under article 11 of the WIPO copyright treaty adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention of such measures. When you convey a covered work, you waive any legal power to forbid circumvention of technological measures to the extent such circumvention is effected by exercising rights under this License with respect to the covered work, and you disclaim any intention to limit operation or modification of the work as a means of enforcing, against the work's users, your or third parties' legal rights to forbid circumvention of technological measures. 4. Conveying Verbatim Copies. You may convey verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice; keep intact all notices stating that this License and any non-permissive terms added in accord with section 7 apply to the code; keep intact all notices of the absence of any warranty; and give all recipients a copy of this License along with the Program. You may charge any price or no price for each copy that you convey, and you may offer support or warranty protection for a fee. 5. Conveying Modified Source Versions. You may convey a work based on the Program, or the modifications to produce it from the Program, in the form of source code under the terms of section 4, provided that you also meet all of these conditions: a) The work must carry prominent notices stating that you modified it, and giving a relevant date. b) The work must carry prominent notices stating that it is released under this License and any conditions added under section 7. This requirement modifies the requirement in section 4 to "keep intact all notices". c) You must license the entire work, as a whole, under this License to anyone who comes into possession of a copy. This License will therefore apply, along with any applicable section 7 additional terms, to the whole of the work, and all its parts, regardless of how they are packaged. This License gives no permission to license the work in any other way, but it does not invalidate such permission if you have separately received it. d) If the work has interactive user interfaces, each must display Appropriate Legal Notices; however, if the Program has interactive interfaces that do not display Appropriate Legal Notices, your work need not make them do so. A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an "aggregate" if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate. 6. Conveying Non-Source Forms. You may convey a covered work in object code form under the terms of sections 4 and 5, provided that you also convey the machine-readable Corresponding Source under the terms of this License, in one of these ways: a) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by the Corresponding Source fixed on a durable physical medium customarily used for software interchange. b) Convey the object code in, or embodied in, a physical product (including a physical distribution medium), accompanied by a written offer, valid for at least three years and valid for as long as you offer spare parts or customer support for that product model, to give anyone who possesses the object code either (1) a copy of the Corresponding Source for all the software in the product that is covered by this License, on a durable physical medium customarily used for software interchange, for a price no more than your reasonable cost of physically performing this conveying of source, or (2) access to copy the Corresponding Source from a network server at no charge. c) Convey individual copies of the object code with a copy of the written offer to provide the Corresponding Source. This alternative is allowed only occasionally and noncommercially, and only if you received the object code with such an offer, in accord with subsection 6b. d) Convey the object code by offering access from a designated place (gratis or for a charge), and offer equivalent access to the Corresponding Source in the same way through the same place at no further charge. You need not require recipients to copy the Corresponding Source along with the object code. If the place to copy the object code is a network server, the Corresponding Source may be on a different server (operated by you or a third party) that supports equivalent copying facilities, provided you maintain clear directions next to the object code saying where to find the Corresponding Source. Regardless of what server hosts the Corresponding Source, you remain obligated to ensure that it is available for as long as needed to satisfy these requirements. e) Convey the object code using peer-to-peer transmission, provided you inform other peers where the object code and Corresponding Source of the work are being offered to the general public at no charge under subsection 6d. A separable portion of the object code, whose source code is excluded from the Corresponding Source as a System Library, need not be included in conveying the object code work. A "User Product" is either (1) a "consumer product", which means any tangible personal property which is normally used for personal, family, or household purposes, or (2) anything designed or sold for incorporation into a dwelling. In determining whether a product is a consumer product, doubtful cases shall be resolved in favor of coverage. For a particular product received by a particular user, "normally used" refers to a typical or common use of that class of product, regardless of the status of the particular user or of the way in which the particular user actually uses, or expects or is expected to use, the product. A product is a consumer product regardless of whether the product has substantial commercial, industrial or non-consumer uses, unless such uses represent the only significant mode of use of the product. "Installation Information" for a User Product means any methods, procedures, authorization keys, or other information required to install and execute modified versions of a covered work in that User Product from a modified version of its Corresponding Source. The information must suffice to ensure that the continued functioning of the modified object code is in no case prevented or interfered with solely because modification has been made. If you convey an object code work under this section in, or with, or specifically for use in, a User Product, and the conveying occurs as part of a transaction in which the right of possession and use of the User Product is transferred to the recipient in perpetuity or for a fixed term (regardless of how the transaction is characterized), the Corresponding Source conveyed under this section must be accompanied by the Installation Information. But this requirement does not apply if neither you nor any third party retains the ability to install modified object code on the User Product (for example, the work has been installed in ROM). The requirement to provide Installation Information does not include a requirement to continue to provide support service, warranty, or updates for a work that has been modified or installed by the recipient, or for the User Product in which it has been modified or installed. Access to a network may be denied when the modification itself materially and adversely affects the operation of the network or violates the rules and protocols for communication across the network. Corresponding Source conveyed, and Installation Information provided, in accord with this section must be in a format that is publicly documented (and with an implementation available to the public in source code form), and must require no special password or key for unpacking, reading or copying. 7. Additional Terms. "Additional permissions" are terms that supplement the terms of this License by making exceptions from one or more of its conditions. Additional permissions that are applicable to the entire Program shall be treated as though they were included in this License, to the extent that they are valid under applicable law. If additional permissions apply only to part of the Program, that part may be used separately under those permissions, but the entire Program remains governed by this License without regard to the additional permissions. When you convey a copy of a covered work, you may at your option remove any additional permissions from that copy, or from any part of it. (Additional permissions may be written to require their own removal in certain cases when you modify the work.) You may place additional permissions on material, added by you to a covered work, for which you have or can give appropriate copyright permission. Notwithstanding any other provision of this License, for material you add to a covered work, you may (if authorized by the copyright holders of that material) supplement the terms of this License with terms: a) Disclaiming warranty or limiting liability differently from the terms of sections 15 and 16 of this License; or b) Requiring preservation of specified reasonable legal notices or author attributions in that material or in the Appropriate Legal Notices displayed by works containing it; or c) Prohibiting misrepresentation of the origin of that material, or requiring that modified versions of such material be marked in reasonable ways as different from the original version; or d) Limiting the use for publicity purposes of names of licensors or authors of the material; or e) Declining to grant rights under trademark law for use of some trade names, trademarks, or service marks; or f) Requiring indemnification of licensors and authors of that material by anyone who conveys the material (or modified versions of it) with contractual assumptions of liability to the recipient, for any liability that these contractual assumptions directly impose on those licensors and authors. All other non-permissive additional terms are considered "further restrictions" within the meaning of section 10. If the Program as you received it, or any part of it, contains a notice stating that it is governed by this License along with a term that is a further restriction, you may remove that term. If a license document contains a further restriction but permits relicensing or conveying under this License, you may add to a covered work material governed by the terms of that license document, provided that the further restriction does not survive such relicensing or conveying. If you add terms to a covered work in accord with this section, you must place, in the relevant source files, a statement of the additional terms that apply to those files, or a notice indicating where to find the applicable terms. Additional terms, permissive or non-permissive, may be stated in the form of a separately written license, or stated as exceptions; the above requirements apply either way. 8. Termination. You may not propagate or modify a covered work except as expressly provided under this License. Any attempt otherwise to propagate or modify it is void, and will automatically terminate your rights under this License (including any patent licenses granted under the third paragraph of section 11). However, if you cease all violation of this License, then your license from a particular copyright holder is reinstated (a) provisionally, unless and until the copyright holder explicitly and finally terminates your license, and (b) permanently, if the copyright holder fails to notify you of the violation by some reasonable means prior to 60 days after the cessation. Moreover, your license from a particular copyright holder is reinstated permanently if the copyright holder notifies you of the violation by some reasonable means, this is the first time you have received notice of violation of this License (for any work) from that copyright holder, and you cure the violation prior to 30 days after your receipt of the notice. Termination of your rights under this section does not terminate the licenses of parties who have received copies or rights from you under this License. If your rights have been terminated and not permanently reinstated, you do not qualify to receive new licenses for the same material under section 10. 9. Acceptance Not Required for Having Copies. You are not required to accept this License in order to receive or run a copy of the Program. Ancillary propagation of a covered work occurring solely as a consequence of using peer-to-peer transmission to receive a copy likewise does not require acceptance. However, nothing other than this License grants you permission to propagate or modify any covered work. These actions infringe copyright if you do not accept this License. Therefore, by modifying or propagating a covered work, you indicate your acceptance of this License to do so. 10. Automatic Licensing of Downstream Recipients. Each time you convey a covered work, the recipient automatically receives a license from the original licensors, to run, modify and propagate that work, subject to this License. You are not responsible for enforcing compliance by third parties with this License. An "entity transaction" is a transaction transferring control of an organization, or substantially all assets of one, or subdividing an organization, or merging organizations. If propagation of a covered work results from an entity transaction, each party to that transaction who receives a copy of the work also receives whatever licenses to the work the party's predecessor in interest had or could give under the previous paragraph, plus a right to possession of the Corresponding Source of the work from the predecessor in interest, if the predecessor has it or can get it with reasonable efforts. You may not impose any further restrictions on the exercise of the rights granted or affirmed under this License. For example, you may not impose a license fee, royalty, or other charge for exercise of rights granted under this License, and you may not initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging that any patent claim is infringed by making, using, selling, offering for sale, or importing the Program or any portion of it. 11. Patents. A "contributor" is a copyright holder who authorizes use under this License of the Program or a work on which the Program is based. The work thus licensed is called the contributor's "contributor version". A contributor's "essential patent claims" are all patent claims owned or controlled by the contributor, whether already acquired or hereafter acquired, that would be infringed by some manner, permitted by this License, of making, using, or selling its contributor version, but do not include claims that would be infringed only as a consequence of further modification of the contributor version. For purposes of this definition, "control" includes the right to grant patent sublicenses in a manner consistent with the requirements of this License. Each contributor grants you a non-exclusive, worldwide, royalty-free patent license under the contributor's essential patent claims, to make, use, sell, offer for sale, import and otherwise run, modify and propagate the contents of its contributor version. In the following three paragraphs, a "patent license" is any express agreement or commitment, however denominated, not to enforce a patent (such as an express permission to practice a patent or covenant not to sue for patent infringement). To "grant" such a patent license to a party means to make such an agreement or commitment not to enforce a patent against the party. If you convey a covered work, knowingly relying on a patent license, and the Corresponding Source of the work is not available for anyone to copy, free of charge and under the terms of this License, through a publicly available network server or other readily accessible means, then you must either (1) cause the Corresponding Source to be so available, or (2) arrange to deprive yourself of the benefit of the patent license for this particular work, or (3) arrange, in a manner consistent with the requirements of this License, to extend the patent license to downstream recipients. "Knowingly relying" means you have actual knowledge that, but for the patent license, your conveying the covered work in a country, or your recipient's use of the covered work in a country, would infringe one or more identifiable patents in that country that you have reason to believe are valid. If, pursuant to or in connection with a single transaction or arrangement, you convey, or propagate by procuring conveyance of, a covered work, and grant a patent license to some of the parties receiving the covered work authorizing them to use, propagate, modify or convey a specific copy of the covered work, then the patent license you grant is automatically extended to all recipients of the covered work and works based on it. A patent license is "discriminatory" if it does not include within the scope of its coverage, prohibits the exercise of, or is conditioned on the non-exercise of one or more of the rights that are specifically granted under this License. You may not convey a covered work if you are a party to an arrangement with a third party that is in the business of distributing software, under which you make payment to the third party based on the extent of your activity of conveying the work, and under which the third party grants, to any of the parties who would receive the covered work from you, a discriminatory patent license (a) in connection with copies of the covered work conveyed by you (or copies made from those copies), or (b) primarily for and in connection with specific products or compilations that contain the covered work, unless you entered into that arrangement, or that patent license was granted, prior to 28 March 2007. Nothing in this License shall be construed as excluding or limiting any implied license or other defenses to infringement that may otherwise be available to you under applicable patent law. 12. No Surrender of Others' Freedom. If conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot convey a covered work so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not convey it at all. For example, if you agree to terms that obligate you to collect a royalty for further conveying from those to whom you convey the Program, the only way you could satisfy both those terms and this License would be to refrain entirely from conveying the Program. 13. Use with the GNU Affero General Public License. Notwithstanding any other provision of this License, you have permission to link or combine any covered work with a work licensed under version 3 of the GNU Affero General Public License into a single combined work, and to convey the resulting work. The terms of this License will continue to apply to the part which is the covered work, but the special requirements of the GNU Affero General Public License, section 13, concerning interaction through a network will apply to the combination as such. 14. Revised Versions of this License. The Free Software Foundation may publish revised and/or new versions of the GNU General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies that a certain numbered version of the GNU General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that numbered version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of the GNU General Public License, you may choose any version ever published by the Free Software Foundation. If the Program specifies that a proxy can decide which future versions of the GNU General Public License can be used, that proxy's public statement of acceptance of a version permanently authorizes you to choose that version for the Program. Later license versions may give you additional or different permissions. However, no additional obligations are imposed on any author or copyright holder as a result of your choosing to follow a later version. 15. Disclaimer of Warranty. THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 16. Limitation of Liability. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 17. Interpretation of Sections 15 and 16. If the disclaimer of warranty and limitation of liability provided above cannot be given local legal effect according to their terms, reviewing courts shall apply local law that most closely approximates an absolute waiver of all civil liability in connection with the Program, unless a warranty or assumption of liability accompanies a copy of the Program in return for a fee. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively state the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program 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. This program 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 . Also add information on how to contact you by electronic and paper mail. If the program does terminal interaction, make it output a short notice like this when it starts in an interactive mode: Copyright (C) This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, your program's commands might be different; for a GUI interface, you would use an "about box". You should also get your employer (if you work as a programmer) or school, if any, to sign a "copyright disclaimer" for the program, if necessary. For more information on this, and how to apply and follow the GNU GPL, see . The GNU General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Lesser General Public License instead of this License. But first, please read . Fairy-Stockfish-fairy_sf_11_1/MANIFEST.in000066400000000000000000000001161366242550200201450ustar00rootroot00000000000000include AUTHORS Copying.txt Readme.md test.py recursive-include src *.h *.cpp Fairy-Stockfish-fairy_sf_11_1/Readme.md000066400000000000000000000376411366242550200201430ustar00rootroot00000000000000# Fairy-Stockfish ## Overview [![Build Status](https://travis-ci.org/ianfab/Fairy-Stockfish.svg?branch=master)](https://travis-ci.org/ianfab/Fairy-Stockfish) [![Build Status](https://ci.appveyor.com/api/projects/status/github/ianfab/Fairy-Stockfish?branch=master&svg=true)](https://ci.appveyor.com/project/ianfab/Fairy-Stockfish/branch/master) [![PyPI version](https://badge.fury.io/py/pyffish.svg)](https://badge.fury.io/py/pyffish) Fairy-Stockfish is a chess variant engine derived from [Stockfish](https://github.com/official-stockfish/Stockfish/) designed for the support of fairy chess variants and easy extensibility with more games. It can play various regional, historical, and modern chess variants as well as [games with user-defined rules](https://github.com/ianfab/Fairy-Stockfish/wiki/Variant-configuration). For [compatibility with graphical user interfaces](https://github.com/ianfab/Fairy-Stockfish/wiki/Usage) it supports the UCI, UCCI, USI, and CECP/XBoard protocols. The goal of the project is to create an engine supporting a large variety of chess-like games, equipped with the powerful search of Stockfish. Despite its generality the [playing strength](https://github.com/ianfab/Fairy-Stockfish/wiki/Playing-strength) is on a very high level in almost all supported variants. Due to its multi-protocol support Fairy-Stockfish works with almost any chess variant GUI. ## Installation You can download the [Windows executable](https://github.com/ianfab/Fairy-Stockfish/releases/latest/download/fairy-stockfish-largeboard_x86-64.exe) or [Linux binary](https://github.com/ianfab/Fairy-Stockfish/releases/latest/download/fairy-stockfish-largeboard_x86-64) from the [latest release](https://github.com/ianfab/Fairy-Stockfish/releases/latest) or [compile the program from source](https://github.com/ianfab/Fairy-Stockfish#compiling-stockfish-yourself-from-the-sources). The program comes without a graphical user interface, so you perhaps want to use it together with a [compatible GUI](https://github.com/ianfab/Fairy-Stockfish/wiki/Usage#guis), or play against it right away online at [pychess](https://www.pychess.org/). Read more about [how to use](https://github.com/ianfab/Fairy-Stockfish/wiki/Usage) Fairy-Stockfish in the wiki. ## Contributing If you appreciate this project, please consider to support it by [donating via paypal](https://paypal.me/FairyStockfish), by [contributing CPU time](https://github.com/ianfab/fishtest/wiki) to the framework for testing of code improvements, or by [contributing to the code](https://github.com/ianfab/Fairy-Stockfish/wiki/Contributing) or documentation. ## Supported games The games currently supported besides chess are listed below. Fairy-Stockfish can also play user-defined variants loaded via a variant configuration file, see the file [`src/variants.ini`](https://github.com/ianfab/Fairy-Stockfish/blob/master/src/variants.ini) and the [wiki](https://github.com/ianfab/Fairy-Stockfish/wiki/Variant-configuration). ### Regional and historical games - [Xiangqi](https://en.wikipedia.org/wiki/Xiangqi), [Manchu](https://en.wikipedia.org/wiki/Manchu_chess), [Minixiangqi](http://mlwi.magix.net/bg/minixiangqi.htm), [Supply chess](https://en.wikipedia.org/wiki/Xiangqi#Variations) - [Shogi](https://en.wikipedia.org/wiki/Shogi), [Shogi variants](https://github.com/ianfab/Fairy-Stockfish#shogi-variants) - [Janggi](https://en.wikipedia.org/wiki/Janggi) - [Makruk](https://en.wikipedia.org/wiki/Makruk), [ASEAN](http://hgm.nubati.net/rules/ASEAN.html), Makpong, Ai-Wok - [Ouk Chatrang](https://en.wikipedia.org/wiki/Makruk#Cambodian_chess), [Kar Ouk](https://en.wikipedia.org/wiki/Makruk#Cambodian_chess) - [Sittuyin](https://en.wikipedia.org/wiki/Sittuyin) - [Shatar](https://en.wikipedia.org/wiki/Shatar), [Jeson Mor](https://en.wikipedia.org/wiki/Jeson_Mor) - [Shatranj](https://en.wikipedia.org/wiki/Shatranj), [Courier](https://en.wikipedia.org/wiki/Courier_chess) ### Chess variants - [Capablanca](https://en.wikipedia.org/wiki/Capablanca_Chess), [Janus](https://en.wikipedia.org/wiki/Janus_Chess), [Modern](https://en.wikipedia.org/wiki/Modern_Chess_(chess_variant)), [Chancellor](https://en.wikipedia.org/wiki/Chancellor_Chess), [Embassy](https://en.wikipedia.org/wiki/Embassy_Chess), [Gothic](https://www.chessvariants.com/large.dir/gothicchess.html), [Capablanca random chess](https://en.wikipedia.org/wiki/Capablanca_Random_Chess) - [Grand](https://en.wikipedia.org/wiki/Grand_Chess), [Shako](https://www.chessvariants.com/large.dir/shako.html), [Centaur](https://www.chessvariants.com/large.dir/contest/royalcourt.html) - [Chess960](https://en.wikipedia.org/wiki/Chess960), [Placement/Pre-Chess](https://www.chessvariants.com/link/placement-chess) - [Crazyhouse](https://en.wikipedia.org/wiki/Crazyhouse), [Loop](https://en.wikipedia.org/wiki/Crazyhouse#Variations), [Chessgi](https://en.wikipedia.org/wiki/Crazyhouse#Variations), [Pocket Knight](http://www.chessvariants.com/other.dir/pocket.html), Capablanca-Crazyhouse - [Bughouse](https://en.wikipedia.org/wiki/Bughouse_chess), [Koedem](http://schachclub-oetigheim.de/wp-content/uploads/2016/04/Koedem-rules.pdf) - [Seirawan](https://en.wikipedia.org/wiki/Seirawan_chess), Seirawan-Crazyhouse - [Amazon](https://en.wikipedia.org/wiki/Amazon_(chess)), [Chigorin](https://en.wikipedia.org/wiki/Chigorin_Chess), [Almost chess](https://en.wikipedia.org/wiki/Almost_Chess) - [Hoppel-Poppel](http://www.chessvariants.com/diffmove.dir/hoppel-poppel.html), New Zealand - [Antichess](https://lichess.org/variant/antichess), [Giveaway](http://www.chessvariants.com/diffobjective.dir/giveaway.old.html), [Suicide](https://www.freechess.org/Help/HelpFiles/suicide_chess.html), [Losers](https://www.chessclub.com/help/Wild17), [Codrus](http://www.binnewirtz.com/Schlagschach1.htm) - [Extinction](https://en.wikipedia.org/wiki/Extinction_chess), [Kinglet](https://en.wikipedia.org/wiki/V._R._Parton#Kinglet_Chess), Three Kings Chess - [King of the Hill](https://en.wikipedia.org/wiki/King_of_the_Hill_(chess)), [Racing Kings](https://en.wikipedia.org/wiki/V._R._Parton#Racing_Kings) - [Three-check](https://en.wikipedia.org/wiki/Three-check_chess), Five-check - [Los Alamos](https://en.wikipedia.org/wiki/Los_Alamos_chess) - [Horde](https://en.wikipedia.org/wiki/Dunsany%27s_Chess#Horde_Chess) - [Knightmate](https://www.chessvariants.com/diffobjective.dir/knightmate.html) ### Shogi variants - [Minishogi](https://en.wikipedia.org/wiki/Minishogi), [EuroShogi](https://en.wikipedia.org/wiki/EuroShogi), [Judkins shogi](https://en.wikipedia.org/wiki/Judkins_shogi) - [Kyoto shogi](https://en.wikipedia.org/wiki/Kyoto_shogi), [Microshogi](https://en.wikipedia.org/wiki/Micro_shogi) - [Dobutsu shogi](https://en.wikipedia.org/wiki/Dōbutsu_shōgi), [Goro goro shogi](https://en.wikipedia.org/wiki/D%C5%8Dbutsu_sh%C5%8Dgi#Variation) ### Related games - [Breakthrough](https://en.wikipedia.org/wiki/Breakthrough_(board_game)) - [Clobber](https://en.wikipedia.org/wiki/Clobber) ## Help See the [Fairy-Stockfish Wiki](https://github.com/ianfab/Fairy-Stockfish/wiki) for more info, or if the required information is not available, open an [issue](https://github.com/ianfab/Fairy-Stockfish/issues). # Stockfish ## Overview [![Build Status](https://travis-ci.org/official-stockfish/Stockfish.svg?branch=master)](https://travis-ci.org/official-stockfish/Stockfish) [![Build Status](https://ci.appveyor.com/api/projects/status/github/official-stockfish/Stockfish?branch=master&svg=true)](https://ci.appveyor.com/project/mcostalba/stockfish/branch/master) [Stockfish](https://stockfishchess.org) is a free, powerful UCI chess engine derived from Glaurung 2.1. It is not a complete chess program and requires a UCI-compatible GUI (e.g. XBoard with PolyGlot, Scid, Cute Chess, eboard, Arena, Sigma Chess, Shredder, Chess Partner or Fritz) in order to be used comfortably. Read the documentation for your GUI of choice for information about how to use Stockfish with it. ## Files This distribution of Stockfish consists of the following files: * Readme.md, the file you are currently reading. * Copying.txt, a text file containing the GNU General Public License version 3. * src, a subdirectory containing the full source code, including a Makefile that can be used to compile Stockfish on Unix-like systems. ## UCI parameters Currently, Stockfish has the following UCI options: * #### Debug Log File Write all communication to and from the engine into a text file. * #### Contempt A positive value for contempt favors middle game positions and avoids draws. * #### Analysis Contempt By default, contempt is set to prefer the side to move. Set this option to "White" or "Black" to analyse with contempt for that side, or "Off" to disable contempt. * #### Threads The number of CPU threads used for searching a position. For best performance, set this equal to the number of CPU cores available. * #### Hash The size of the hash table in MB. * #### Clear Hash Clear the hash table. * #### Ponder Let Stockfish ponder its next move while the opponent is thinking. * #### MultiPV Output the N best lines (principal variations, PVs) when searching. Leave at 1 for best performance. * #### Skill Level Lower the Skill Level in order to make Stockfish play weaker (see also UCI_LimitStrength). Internally, MultiPV is enabled, and with a certain probability depending on the Skill Level a weaker move will be played. * #### UCI_LimitStrength Enable weaker play aiming for an Elo rating as set by UCI_Elo. This option overrides Skill Level. * #### UCI_Elo If enabled by UCI_LimitStrength, aim for an engine strength of the given Elo. This Elo rating has been calibrated at a time control of 60s+0.6s and anchored to CCRL 40/4. * #### Move Overhead Assume a time delay of x ms due to network and GUI overheads. This is useful to avoid losses on time in those cases. * #### Minimum Thinking Time Search for at least x ms per move. * #### Slow Mover Lower values will make Stockfish take less time in games, higher values will make it think longer. * #### nodestime Tells the engine to use nodes searched instead of wall time to account for elapsed time. Useful for engine testing. * #### UCI_Chess960 An option handled by your GUI. If true, Stockfish will play Chess960. * #### UCI_AnalyseMode An option handled by your GUI. * #### SyzygyPath Path to the folders/directories storing the Syzygy tablebase files. Multiple directories are to be separated by ";" on Windows and by ":" on Unix-based operating systems. Do not use spaces around the ";" or ":". Example: `C:\tablebases\wdl345;C:\tablebases\wdl6;D:\tablebases\dtz345;D:\tablebases\dtz6` It is recommended to store .rtbw files on an SSD. There is no loss in storing the .rtbz files on a regular HD. It is recommended to verify all md5 checksums of the downloaded tablebase files (`md5sum -c checksum.md5`) as corruption will lead to engine crashes. * #### SyzygyProbeDepth Minimum remaining search depth for which a position is probed. Set this option to a higher value to probe less agressively if you experience too much slowdown (in terms of nps) due to TB probing. * #### Syzygy50MoveRule Disable to let fifty-move rule draws detected by Syzygy tablebase probes count as wins or losses. This is useful for ICCF correspondence games. * #### SyzygyProbeLimit Limit Syzygy tablebase probing to positions with at most this many pieces left (including kings and pawns). ## What to expect from Syzygybases? If the engine is searching a position that is not in the tablebases (e.g. a position with 8 pieces), it will access the tablebases during the search. If the engine reports a very large score (typically 153.xx), this means that it has found a winning line into a tablebase position. If the engine is given a position to search that is in the tablebases, it will use the tablebases at the beginning of the search to preselect all good moves, i.e. all moves that preserve the win or preserve the draw while taking into account the 50-move rule. It will then perform a search only on those moves. **The engine will not move immediately**, unless there is only a single good move. **The engine likely will not report a mate score even if the position is known to be won.** It is therefore clear that this behaviour is not identical to what one might be used to with Nalimov tablebases. There are technical reasons for this difference, the main technical reason being that Nalimov tablebases use the DTM metric (distance-to-mate), while Syzygybases use a variation of the DTZ metric (distance-to-zero, zero meaning any move that resets the 50-move counter). This special metric is one of the reasons that Syzygybases are more compact than Nalimov tablebases, while still storing all information needed for optimal play and in addition being able to take into account the 50-move rule. ## Compiling Stockfish yourself from the sources On Unix-like systems, it should be possible to compile Stockfish directly from the source code with the included Makefile. Stockfish has support for 32 or 64-bit CPUs, the hardware POPCNT instruction, big-endian machines such as Power PC, and other platforms. In general it is recommended to run `make help` to see a list of make targets with corresponding descriptions. When not using the Makefile to compile (for instance with Microsoft MSVC) you need to manually set/unset some switches in the compiler command line; see file *types.h* for a quick reference. When reporting an issue or a bug, please tell us which version and compiler you used to create your executable. These informations can be found by typing the following commands in a console: ``` ./stockfish compiler ``` ## Understanding the code base and participating in the project Stockfish's improvement over the last couple of years has been a great community effort. There are a few ways to help contribute to its growth. ### Donating hardware Improving Stockfish requires a massive amount of testing. You can donate your hardware resources by installing the [Fishtest Worker](https://github.com/glinscott/fishtest/wiki/Running-the-worker:-overview) and view the current tests on [Fishtest](https://tests.stockfishchess.org/tests). ### Improving the code If you want to help improve the code, there are several valuable resources: * [In this wiki,](https://www.chessprogramming.org) many techniques used in Stockfish are explained with a lot of background information. * [The section on Stockfish](https://www.chessprogramming.org/Stockfish) describes many features and techniques used by Stockfish. However, it is generic rather than being focused on Stockfish's precise implementation. Nevertheless, a helpful resource. * The latest source can always be found on [GitHub](https://github.com/official-stockfish/Stockfish). Discussions about Stockfish take place in the [FishCooking](https://groups.google.com/forum/#!forum/fishcooking) group and engine testing is done on [Fishtest](https://tests.stockfishchess.org/tests). If you want to help improve Stockfish, please read this [guideline](https://github.com/glinscott/fishtest/wiki/Creating-my-first-test) first, where the basics of Stockfish development are explained. ## Terms of use Stockfish is free, and distributed under the **GNU General Public License version 3** (GPL v3). Essentially, this means that you are free to do almost exactly what you want with the program, including distributing it among your friends, making it available for download from your web site, selling it (either by itself or as part of some bigger software package), or using it as the starting point for a software project of your own. The only real limitation is that whenever you distribute Stockfish in some way, you must always include the full source code, or a pointer to where the source code can be found. If you make any changes to the source code, these changes must also be made available under the GPL. For full details, read the copy of the GPL v3 found in the file named *Copying.txt*. Fairy-Stockfish-fairy_sf_11_1/Top CPU Contributors.txt000066400000000000000000000171331366242550200230070ustar00rootroot00000000000000Contributors with >10,000 CPU hours as of January 7, 2020 Thank you! Username CPU Hours Games played -------------------------------------------------- noobpwnftw 9305707 695548021 mlang 780050 61648867 dew 621626 43921547 mibere 524702 42238645 crunchy 354587 27344275 cw 354495 27274181 fastgm 332801 22804359 JojoM 295750 20437451 CSU_Dynasty 262015 21828122 Fisherman 232181 18939229 ctoks 218866 17622052 glinscott 201989 13780820 tvijlbrief 201204 15337115 velislav 188630 14348485 gvreuls 187164 15149976 bking_US 180289 11876016 nordlandia 172076 13467830 leszek 157152 11443978 Thanar 148021 12365359 spams 141975 10319326 drabel 138073 11121749 vdv 137850 9394330 mgrabiak 133578 10454324 TueRens 132485 10878471 bcross 129683 11557084 marrco 126078 9356740 sqrt2 125830 9724586 robal 122873 9593418 vdbergh 120766 8926915 malala 115926 8002293 CoffeeOne 114241 5004100 dsmith 113189 7570238 BrunoBanani 104644 7436849 Data 92328 8220352 mhoram 89333 6695109 davar 87924 7009424 xoto 81094 6869316 ElbertoOne 80899 7023771 grandphish2 78067 6160199 brabos 77212 6186135 psk 75733 5984901 BRAVONE 73875 5054681 sunu 70771 5597972 sterni1971 70605 5590573 MaZePallas 66886 5188978 Vizvezdenec 63708 4967313 nssy 63462 5259388 jromang 61634 4940891 teddybaer 61231 5407666 Pking_cda 60099 5293873 solarlight 57469 5028306 dv8silencer 56913 3883992 tinker 54936 4086118 renouve 49732 3501516 Freja 49543 3733019 robnjr 46972 4053117 rap 46563 3219146 Bobo1239 46036 3817196 ttruscott 45304 3649765 racerschmacer 44881 3975413 finfish 44764 3370515 eva42 41783 3599691 biffhero 40263 3111352 bigpen0r 39817 3291647 mhunt 38871 2691355 ronaldjerum 38820 3240695 Antihistamine 38785 2761312 pb00067 38038 3086320 speedycpu 37591 3003273 rkl 37207 3289580 VoyagerOne 37050 3441673 jbwiebe 35320 2805433 cuistot 34191 2146279 homyur 33927 2850481 manap 32873 2327384 gri 32538 2515779 oryx 31267 2899051 EthanOConnor 30959 2090311 SC 30832 2730764 csnodgrass 29505 2688994 jmdana 29458 2205261 strelock 28219 2067805 jkiiski 27832 1904470 Pyafue 27533 1902349 Garf 27515 2747562 eastorwest 27421 2317535 slakovv 26903 2021889 Prcuvu 24835 2170122 anst 24714 2190091 hyperbolic.tom 24319 2017394 Patrick_G 23687 1801617 Sharaf_DG 22896 1786697 nabildanial 22195 1519409 chriswk 21931 1868317 achambord 21665 1767323 Zirie 20887 1472937 team-oh 20217 1636708 Isidor 20096 1680691 ncfish1 19931 1520927 nesoneg 19875 1463031 Spprtr 19853 1548165 JanErik 19849 1703875 agg177 19478 1395014 SFTUser 19231 1567999 xor12 19017 1680165 sg4032 18431 1641865 rstoesser 18118 1293588 MazeOfGalious 17917 1629593 j3corre 17743 941444 cisco2015 17725 1690126 ianh2105 17706 1632562 dex 17678 1467203 jundery 17194 1115855 iisiraider 17019 1101015 horst.prack 17012 1465656 Adrian.Schmidt123 16563 1281436 purplefishies 16342 1092533 wei 16274 1745989 ville 16144 1384026 eudhan 15712 1283717 OuaisBla 15581 972000 DragonLord 15559 1162790 dju 14716 875569 chris 14479 1487385 0xB00B1ES 14079 1001120 OssumOpossum 13776 1007129 enedene 13460 905279 bpfliegel 13346 884523 Ente 13198 1156722 IgorLeMasson 13087 1147232 jpulman 13000 870599 ako027ako 12775 1173203 Nikolay.IT 12352 1068349 Andrew Grant 12327 895539 joster 12008 950160 AdrianSA 11996 804972 Nesa92 11455 1111993 fatmurphy 11345 853210 Dark_wizzie 11108 1007152 modolief 10869 896470 mschmidt 10757 803401 infinity 10594 727027 mabichito 10524 749391 Thomas A. Anderson 10474 732094 thijsk 10431 719357 Flopzee 10339 894821 crocogoat 10104 1013854 SapphireBrand 10104 969604 stocky 10017 699440 Fairy-Stockfish-fairy_sf_11_1/appveyor.yml000066400000000000000000000040611366242550200210020ustar00rootroot00000000000000version: 1.0.{build} clone_depth: 50 branches: only: - master - merge - appveyor # Operating system (build VM template) os: Visual Studio 2017 # Build platform, i.e. x86, x64, AnyCPU. This setting is optional. platform: - x86 - x64 # build Configuration, i.e. Debug, Release, etc. configuration: - Debug - Release matrix: # The build fail immediately once one of the job fails fast_finish: true # Scripts that are called at very beginning, before repo cloning init: - cmake --version - msbuild /version before_build: - ps: | # Get sources $src = get-childitem -Path *.cpp -Recurse -Exclude pyffish.cpp | select -ExpandProperty FullName $src = $src -join ' ' $src = $src.Replace("\", "/") # Build CMakeLists.txt $t = 'cmake_minimum_required(VERSION 3.8)', 'project(Stockfish)', 'set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/src)', 'set(source_files', $src, ')', 'add_executable(stockfish ${source_files})' # Write CMakeLists.txt withouth BOM $MyPath = (Get-Item -Path "." -Verbose).FullName + '\CMakeLists.txt' $Utf8NoBomEncoding = New-Object System.Text.UTF8Encoding $False [System.IO.File]::WriteAllLines($MyPath, $t, $Utf8NoBomEncoding) # Obtain bench reference from git log $b = git log HEAD | sls "\b[Bb]ench[ :]+[0-9]{7}" | select -first 1 $bench = $b -match '\D+(\d+)' | % { $matches[1] } Write-Host "Reference bench:" $bench $g = "Visual Studio 15 2017" If (${env:PLATFORM} -eq 'x64') { $g = $g + ' Win64' } cmake -G "${g}" . Write-Host "Generated files for: " $g build_script: - cmake --build . --config %CONFIGURATION% -- /verbosity:minimal before_test: - cd src/%CONFIGURATION% - stockfish bench 2> out.txt >NUL - ps: | # Verify bench number $s = (gc "./out.txt" | out-string) $r = ($s -match 'Nodes searched \D+(\d+)' | % { $matches[1] }) Write-Host "Engine bench:" $r Write-Host "Reference bench:" $bench If ($r -ne $bench) { exit 1 } Fairy-Stockfish-fairy_sf_11_1/appveyor_python.yml000066400000000000000000000032661366242550200224110ustar00rootroot00000000000000environment: matrix: - PYTHON: "C:\\Python36-x64" - PYTHON: "C:\\Python37-x64" - PYTHON: "C:\\Python38-x64" init: - "ECHO %PYTHON% %PYTHON_ARCH% %MSVC_VERSION%" install: - ps: | if (-not (Test-Path $env:PYTHON)) { curl -o install_python.ps1 https://raw.githubusercontent.com/matthew-brett/multibuild/11a389d78892cf90addac8f69433d5e22bfa422a/install_python.ps1 .\install_python.ps1 } - ps: if (-not (Test-Path $env:PYTHON)) { throw "No $env:PYTHON" } - "set PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%" - python --version # We need wheel installed to build wheels - "%PYTHON%\\python.exe -m pip install wheel" build: off test_script: # Put your test command here. # If you don't need to build C extensions on 64-bit Python 3.3 or 3.4, # you can remove "build.cmd" from the front of the command, as it's # only needed to support those cases. # Note that you must use the environment variable %PYTHON% to refer to # the interpreter you're using - Appveyor does not do anything special # to put the Python version you want to use on PATH. - "%PYTHON%\\python.exe setup.py test" after_test: # This step builds your wheels. # Again, you only need build.cmd if you're building C extensions for # 64-bit Python 3.3/3.4. And you need to use %PYTHON% to get the correct # interpreter - "%PYTHON%\\python.exe setup.py bdist_wheel" artifacts: # bdist_wheel puts your built wheel in the dist directory - path: dist\* #on_success: # You can use this step to upload your artifacts to a public website. # See Appveyor's documentation for more details. Or you can simply # access your wheels from the Appveyor "artifacts" tab for your build. Fairy-Stockfish-fairy_sf_11_1/setup.py000066400000000000000000000023521366242550200201250ustar00rootroot00000000000000# -*- coding: utf-8 -*- from setuptools import setup, Extension from glob import glob import platform import io args = ["-DLARGEBOARDS", "-DPRECOMPUTED_MAGICS", "-flto", "-std=c++11"] if not platform.python_compiler().startswith("MSC"): args.append("-Wno-date-time") if "64bit" in platform.architecture(): args.append("-DIS_64BIT") CLASSIFIERS = [ "Development Status :: 3 - Alpha", "License :: OSI Approved :: GNU General Public License v3 (GPLv3)", "Programming Language :: Python :: 3", "Operating System :: OS Independent", ] with io.open("Readme.md", "r", encoding="utf8") as fh: long_description = fh.read().strip() pyffish_module = Extension( "pyffish", sources=glob("src/*.cpp") + glob("src/syzygy/*.cpp"), extra_compile_args=args) setup(name="pyffish", version="0.0.48", description="Fairy-Stockfish Python wrapper", long_description=long_description, long_description_content_type="text/markdown", author="Bajusz Tamás", author_email="gbtami@gmail.com", license="GPL3", classifiers=CLASSIFIERS, url="https://github.com/gbtami/Fairy-Stockfish", python_requires=">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*", ext_modules=[pyffish_module] ) Fairy-Stockfish-fairy_sf_11_1/src/000077500000000000000000000000001366242550200172005ustar00rootroot00000000000000Fairy-Stockfish-fairy_sf_11_1/src/Makefile000066400000000000000000000343421366242550200206460ustar00rootroot00000000000000# Stockfish, a UCI chess playing engine derived from Glaurung 2.1 # Copyright (C) 2004-2008 Tord Romstad (Glaurung author) # Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad # Copyright (C) 2015-2019 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad # # Stockfish 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. # # Stockfish 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 . ### ========================================================================== ### Section 1. General Configuration ### ========================================================================== ### Executable name ifeq ($(COMP),mingw) EXE = stockfish.exe else EXE = stockfish endif ### Installation dir definitions PREFIX = /usr/local BINDIR = $(PREFIX)/bin ### Built-in benchmark for pgo-builds PGOBENCH = ./$(EXE) bench ### Object files OBJS = benchmark.o bitbase.o bitboard.o endgame.o evaluate.o main.o \ material.o misc.o movegen.o movepick.o partner.o parser.o pawns.o piece.o position.o psqt.o \ search.o thread.o timeman.o tt.o uci.o ucioption.o variant.o xboard.o syzygy/tbprobe.o ### Establish the operating system name KERNEL = $(shell uname -s) ifeq ($(KERNEL),Linux) OS = $(shell uname -o) endif ### ========================================================================== ### Section 2. High-level Configuration ### ========================================================================== # # flag --- Comp switch --- Description # ---------------------------------------------------------------------------- # # debug = yes/no --- -DNDEBUG --- Enable/Disable debug mode # sanitize = undefined/thread/no (-fsanitize ) # --- ( undefined ) --- enable undefined behavior checks # --- ( thread ) --- enable threading error checks # optimize = yes/no --- (-O3/-fast etc.) --- Enable/Disable optimizations # arch = (name) --- (-arch) --- Target architecture # bits = 64/32 --- -DIS_64BIT --- 64-/32-bit operating system # prefetch = yes/no --- -DUSE_PREFETCH --- Use prefetch asm-instruction # popcnt = yes/no --- -DUSE_POPCNT --- Use popcnt asm-instruction # sse = yes/no --- -msse --- Use Intel Streaming SIMD Extensions # pext = yes/no --- -DUSE_PEXT --- Use pext x86_64 asm-instruction # # Note that Makefile is space sensitive, so when adding new architectures # or modifying existing flags, you have to make sure there are no extra spaces # at the end of the line for flag values. ### 2.1. General and architecture defaults largeboards = no precomputedmagics = yes optimize = yes debug = no sanitize = no bits = 32 prefetch = no popcnt = no sse = no pext = no ### 2.2 Architecture specific ifeq ($(ARCH),general-32) arch = any endif ifeq ($(ARCH),x86-32-old) arch = i386 endif ifeq ($(ARCH),x86-32) arch = i386 prefetch = yes sse = yes endif ifeq ($(ARCH),general-64) arch = any bits = 64 endif ifeq ($(ARCH),x86-64) arch = x86_64 bits = 64 prefetch = yes sse = yes endif ifeq ($(ARCH),x86-64-modern) arch = x86_64 bits = 64 prefetch = yes popcnt = yes sse = yes endif ifeq ($(ARCH),x86-64-bmi2) arch = x86_64 bits = 64 prefetch = yes popcnt = yes sse = yes pext = yes precomputedmagics = no endif ifeq ($(ARCH),armv7) arch = armv7 prefetch = yes endif ifeq ($(ARCH),ppc-32) arch = ppc endif ifeq ($(ARCH),ppc-64) arch = ppc64 bits = 64 popcnt = yes prefetch = yes endif ### ========================================================================== ### Section 3. Low-level configuration ### ========================================================================== ### 3.1 Selecting compiler (default = gcc) CXXFLAGS += -Wall -Wcast-qual -fno-exceptions -std=c++11 $(EXTRACXXFLAGS) DEPENDFLAGS += -std=c++11 LDFLAGS += $(EXTRALDFLAGS) # Compile version with support for large board variants # Use precomputed magics by default if pext is not available ifneq ($(largeboards),no) CXXFLAGS += -DLARGEBOARDS ifeq ($(precomputedmagics),yes) CXXFLAGS += -DPRECOMPUTED_MAGICS endif endif ifeq ($(COMP),) COMP=gcc endif ifeq ($(COMP),gcc) comp=gcc CXX=g++ CXXFLAGS += -Wextra -Wshadow ifeq ($(largeboards),no) CXXFLAGS += -pedantic endif ifeq ($(ARCH),armv7) ifeq ($(OS),Android) CXXFLAGS += -m$(bits) LDFLAGS += -m$(bits) endif else CXXFLAGS += -m$(bits) LDFLAGS += -m$(bits) endif ifneq ($(KERNEL),Darwin) LDFLAGS += -Wl,--no-as-needed endif endif ifeq ($(COMP),mingw) comp=mingw ifeq ($(KERNEL),Linux) ifeq ($(bits),64) ifeq ($(shell which x86_64-w64-mingw32-c++-posix),) CXX=x86_64-w64-mingw32-c++ else CXX=x86_64-w64-mingw32-c++-posix endif else ifeq ($(shell which i686-w64-mingw32-c++-posix),) CXX=i686-w64-mingw32-c++ else CXX=i686-w64-mingw32-c++-posix endif endif else CXX=g++ endif CXXFLAGS += -Wextra -Wshadow LDFLAGS += -static endif ifeq ($(COMP),icc) comp=icc CXX=icpc CXXFLAGS += -diag-disable 1476,10120 -Wcheck -Wabi -Wdeprecated -strict-ansi endif ifeq ($(COMP),clang) comp=clang CXX=clang++ CXXFLAGS += -pedantic -Wextra -Wshadow ifneq ($(KERNEL),Darwin) ifneq ($(KERNEL),OpenBSD) LDFLAGS += -latomic endif endif ifeq ($(ARCH),armv7) ifeq ($(OS),Android) CXXFLAGS += -m$(bits) LDFLAGS += -m$(bits) endif else CXXFLAGS += -m$(bits) LDFLAGS += -m$(bits) endif endif ifeq ($(comp),icc) profile_make = icc-profile-make profile_use = icc-profile-use else ifeq ($(comp),clang) profile_make = clang-profile-make profile_use = clang-profile-use else profile_make = gcc-profile-make profile_use = gcc-profile-use endif endif ifeq ($(KERNEL),Darwin) CXXFLAGS += -arch $(arch) -mmacosx-version-min=10.9 LDFLAGS += -arch $(arch) -mmacosx-version-min=10.9 endif ### Travis CI script uses COMPILER to overwrite CXX ifdef COMPILER COMPCXX=$(COMPILER) endif ### Allow overwriting CXX from command line ifdef COMPCXX CXX=$(COMPCXX) endif ### On mingw use Windows threads, otherwise POSIX ifneq ($(comp),mingw) # On Android Bionic's C library comes with its own pthread implementation bundled in ifneq ($(OS),Android) # Haiku has pthreads in its libroot, so only link it in on other platforms ifneq ($(KERNEL),Haiku) LDFLAGS += -lpthread endif endif endif ### 3.2.1 Debugging ifeq ($(debug),no) CXXFLAGS += -DNDEBUG else CXXFLAGS += -g endif ### 3.2.2 Debugging with undefined behavior sanitizers ifneq ($(sanitize),no) CXXFLAGS += -g3 -fsanitize=$(sanitize) -fuse-ld=gold LDFLAGS += -fsanitize=$(sanitize) -fuse-ld=gold endif ### 3.3 Optimization ifeq ($(optimize),yes) CXXFLAGS += -O3 ifeq ($(comp),gcc) ifeq ($(OS), Android) CXXFLAGS += -fno-gcse -mthumb -march=armv7-a -mfloat-abi=softfp endif endif ifeq ($(comp),$(filter $(comp),gcc clang icc)) ifeq ($(KERNEL),Darwin) CXXFLAGS += -mdynamic-no-pic endif endif endif ### 3.4 Bits ifeq ($(bits),64) CXXFLAGS += -DIS_64BIT endif ### 3.5 prefetch ifeq ($(prefetch),yes) ifeq ($(sse),yes) CXXFLAGS += -msse DEPENDFLAGS += -msse endif else CXXFLAGS += -DNO_PREFETCH endif ### 3.6 popcnt ifeq ($(popcnt),yes) ifeq ($(arch),ppc64) CXXFLAGS += -DUSE_POPCNT else ifeq ($(comp),icc) CXXFLAGS += -msse3 -DUSE_POPCNT else CXXFLAGS += -msse3 -mpopcnt -DUSE_POPCNT endif endif ### 3.7 pext ifeq ($(pext),yes) CXXFLAGS += -DUSE_PEXT ifeq ($(comp),$(filter $(comp),gcc clang mingw)) CXXFLAGS += -msse4 -mbmi2 endif endif ### 3.8 Link Time Optimization, it works since gcc 4.5 but not on mingw under Windows. ### This is a mix of compile and link time options because the lto link phase ### needs access to the optimization flags. ifeq ($(optimize),yes) ifeq ($(debug), no) ifeq ($(comp),$(filter $(comp),gcc clang)) CXXFLAGS += -flto LDFLAGS += $(CXXFLAGS) endif ifeq ($(comp),mingw) ifeq ($(KERNEL),Linux) CXXFLAGS += -flto LDFLAGS += $(CXXFLAGS) endif endif endif endif ### 3.9 Android 5 can only run position independent executables. Note that this ### breaks Android 4.0 and earlier. ifeq ($(OS), Android) CXXFLAGS += -fPIE LDFLAGS += -fPIE -pie endif ### ========================================================================== ### Section 4. Public targets ### ========================================================================== help: @echo "" @echo "To compile stockfish, type: " @echo "" @echo "make target ARCH=arch [COMP=compiler] [COMPCXX=cxx]" @echo "" @echo "Supported targets:" @echo "" @echo "build > Standard build" @echo "profile-build > PGO build" @echo "strip > Strip executable" @echo "install > Install executable" @echo "clean > Clean up" @echo "" @echo "Supported archs:" @echo "" @echo "x86-64-bmi2 > x86 64-bit with pext support (also enables SSE4)" @echo "x86-64-modern > x86 64-bit with popcnt support (also enables SSE3)" @echo "x86-64 > x86 64-bit generic" @echo "x86-32 > x86 32-bit (also enables SSE)" @echo "x86-32-old > x86 32-bit fall back for old hardware" @echo "ppc-64 > PPC 64-bit" @echo "ppc-32 > PPC 32-bit" @echo "armv7 > ARMv7 32-bit" @echo "general-64 > unspecified 64-bit" @echo "general-32 > unspecified 32-bit" @echo "" @echo "Supported compilers:" @echo "" @echo "gcc > Gnu compiler (default)" @echo "mingw > Gnu compiler with MinGW under Windows" @echo "clang > LLVM Clang compiler" @echo "icc > Intel compiler" @echo "" @echo "Simple examples. If you don't know what to do, you likely want to run: " @echo "" @echo "make build ARCH=x86-64 (This is for 64-bit systems)" @echo "make build ARCH=x86-32 (This is for 32-bit systems)" @echo "" @echo "Advanced examples, for experienced users: " @echo "" @echo "make build ARCH=x86-64 COMP=clang" @echo "make profile-build ARCH=x86-64-bmi2 COMP=gcc COMPCXX=g++-4.8" @echo "" @echo "Version for large boards (only GCC and mingw, 64-bit required): " @echo "" @echo "make build ARCH=x86-64 COMP=gcc largeboards=yes" @echo "" .PHONY: help build profile-build strip install clean objclean profileclean help \ config-sanity icc-profile-use icc-profile-make gcc-profile-use gcc-profile-make \ clang-profile-use clang-profile-make build: config-sanity $(MAKE) ARCH=$(ARCH) COMP=$(COMP) all profile-build: config-sanity objclean profileclean @echo "" @echo "Step 1/4. Building instrumented executable ..." $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_make) @echo "" @echo "Step 2/4. Running benchmark for pgo-build ..." $(PGOBENCH) > /dev/null @echo "" @echo "Step 3/4. Building optimized executable ..." $(MAKE) ARCH=$(ARCH) COMP=$(COMP) objclean $(MAKE) ARCH=$(ARCH) COMP=$(COMP) $(profile_use) @echo "" @echo "Step 4/4. Deleting profile data ..." $(MAKE) ARCH=$(ARCH) COMP=$(COMP) profileclean strip: strip $(EXE) install: -mkdir -p -m 755 $(BINDIR) -cp $(EXE) $(BINDIR) -strip $(BINDIR)/$(EXE) #clean all clean: objclean profileclean @rm -f .depend *~ core # clean binaries and objects objclean: @rm -f $(EXE) *.o ./syzygy/*.o # clean auxiliary profiling files profileclean: @rm -rf profdir @rm -f bench.txt *.gcda ./syzygy/*.gcda *.gcno ./syzygy/*.gcno @rm -f stockfish.profdata *.profraw default: help ### ========================================================================== ### Section 5. Private targets ### ========================================================================== all: $(EXE) .depend config-sanity: @echo "" @echo "Config:" @echo "debug: '$(debug)'" @echo "sanitize: '$(sanitize)'" @echo "optimize: '$(optimize)'" @echo "arch: '$(arch)'" @echo "bits: '$(bits)'" @echo "kernel: '$(KERNEL)'" @echo "os: '$(OS)'" @echo "prefetch: '$(prefetch)'" @echo "popcnt: '$(popcnt)'" @echo "sse: '$(sse)'" @echo "pext: '$(pext)'" @echo "" @echo "Flags:" @echo "CXX: $(CXX)" @echo "CXXFLAGS: $(CXXFLAGS)" @echo "LDFLAGS: $(LDFLAGS)" @echo "" @echo "Testing config sanity. If this fails, try 'make help' ..." @echo "" @test "$(debug)" = "yes" || test "$(debug)" = "no" @test "$(sanitize)" = "undefined" || test "$(sanitize)" = "thread" || test "$(sanitize)" = "address" || test "$(sanitize)" = "no" @test "$(optimize)" = "yes" || test "$(optimize)" = "no" @test "$(arch)" = "any" || test "$(arch)" = "x86_64" || test "$(arch)" = "i386" || \ test "$(arch)" = "ppc64" || test "$(arch)" = "ppc" || test "$(arch)" = "armv7" @test "$(bits)" = "32" || test "$(bits)" = "64" @test "$(prefetch)" = "yes" || test "$(prefetch)" = "no" @test "$(popcnt)" = "yes" || test "$(popcnt)" = "no" @test "$(sse)" = "yes" || test "$(sse)" = "no" @test "$(pext)" = "yes" || test "$(pext)" = "no" @test "$(comp)" = "gcc" || test "$(comp)" = "icc" || test "$(comp)" = "mingw" || test "$(comp)" = "clang" $(EXE): $(OBJS) $(CXX) -o $@ $(OBJS) $(LDFLAGS) clang-profile-make: $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \ EXTRACXXFLAGS='-fprofile-instr-generate ' \ EXTRALDFLAGS=' -fprofile-instr-generate' \ all clang-profile-use: llvm-profdata merge -output=stockfish.profdata *.profraw $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \ EXTRACXXFLAGS='-fprofile-instr-use=stockfish.profdata' \ EXTRALDFLAGS='-fprofile-use ' \ all gcc-profile-make: $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \ EXTRACXXFLAGS='-fprofile-generate' \ EXTRALDFLAGS='-lgcov' \ all gcc-profile-use: $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \ EXTRACXXFLAGS='-fprofile-use -fno-peel-loops -fno-tracer' \ EXTRALDFLAGS='-lgcov' \ all icc-profile-make: @mkdir -p profdir $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \ EXTRACXXFLAGS='-prof-gen=srcpos -prof_dir ./profdir' \ all icc-profile-use: $(MAKE) ARCH=$(ARCH) COMP=$(COMP) \ EXTRACXXFLAGS='-prof_use -prof_dir ./profdir' \ all .depend: -@$(CXX) $(DEPENDFLAGS) -MM $(OBJS:.o=.cpp) > $@ 2> /dev/null -include .depend Fairy-Stockfish-fairy_sf_11_1/src/benchmark.cpp000066400000000000000000000151211366242550200216360ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include #include #include "position.h" #include "uci.h" using namespace std; namespace { const vector Defaults = { "setoption name UCI_Chess960 value false", "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1", "r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq - 0 10", "8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 11", "4rrk1/pp1n3p/3q2pQ/2p1pb2/2PP4/2P3N1/P2B2PP/4RRK1 b - - 7 19", "rq3rk1/ppp2ppp/1bnpb3/3N2B1/3NP3/7P/PPPQ1PP1/2KR3R w - - 7 14 moves d4e6", "r1bq1r1k/1pp1n1pp/1p1p4/4p2Q/4Pp2/1BNP4/PPP2PPP/3R1RK1 w - - 2 14 moves g2g4", "r3r1k1/2p2ppp/p1p1bn2/8/1q2P3/2NPQN2/PPP3PP/R4RK1 b - - 2 15", "r1bbk1nr/pp3p1p/2n5/1N4p1/2Np1B2/8/PPP2PPP/2KR1B1R w kq - 0 13", "r1bq1rk1/ppp1nppp/4n3/3p3Q/3P4/1BP1B3/PP1N2PP/R4RK1 w - - 1 16", "4r1k1/r1q2ppp/ppp2n2/4P3/5Rb1/1N1BQ3/PPP3PP/R5K1 w - - 1 17", "2rqkb1r/ppp2p2/2npb1p1/1N1Nn2p/2P1PP2/8/PP2B1PP/R1BQK2R b KQ - 0 11", "r1bq1r1k/b1p1npp1/p2p3p/1p6/3PP3/1B2NN2/PP3PPP/R2Q1RK1 w - - 1 16", "3r1rk1/p5pp/bpp1pp2/8/q1PP1P2/b3P3/P2NQRPP/1R2B1K1 b - - 6 22", "r1q2rk1/2p1bppp/2Pp4/p6b/Q1PNp3/4B3/PP1R1PPP/2K4R w - - 2 18", "4k2r/1pb2ppp/1p2p3/1R1p4/3P4/2r1PN2/P4PPP/1R4K1 b - - 3 22", "3q2k1/pb3p1p/4pbp1/2r5/PpN2N2/1P2P2P/5PP1/Q2R2K1 b - - 4 26", "6k1/6p1/6Pp/ppp5/3pn2P/1P3K2/1PP2P2/3N4 b - - 0 1", "3b4/5kp1/1p1p1p1p/pP1PpP1P/P1P1P3/3KN3/8/8 w - - 0 1", "2K5/p7/7P/5pR1/8/5k2/r7/8 w - - 0 1 moves g5g6 f3e3 g6g5 e3f3", "8/6pk/1p6/8/PP3p1p/5P2/4KP1q/3Q4 w - - 0 1", "7k/3p2pp/4q3/8/4Q3/5Kp1/P6b/8 w - - 0 1", "8/2p5/8/2kPKp1p/2p4P/2P5/3P4/8 w - - 0 1", "8/1p3pp1/7p/5P1P/2k3P1/8/2K2P2/8 w - - 0 1", "8/pp2r1k1/2p1p3/3pP2p/1P1P1P1P/P5KR/8/8 w - - 0 1", "8/3p4/p1bk3p/Pp6/1Kp1PpPp/2P2P1P/2P5/5B2 b - - 0 1", "5k2/7R/4P2p/5K2/p1r2P1p/8/8/8 b - - 0 1", "6k1/6p1/P6p/r1N5/5p2/7P/1b3PP1/4R1K1 w - - 0 1", "1r3k2/4q3/2Pp3b/3Bp3/2Q2p2/1p1P2P1/1P2KP2/3N4 w - - 0 1", "6k1/4pp1p/3p2p1/P1pPb3/R7/1r2P1PP/3B1P2/6K1 w - - 0 1", "8/3p3B/5p2/5P2/p7/PP5b/k7/6K1 w - - 0 1", "5rk1/q6p/2p3bR/1pPp1rP1/1P1Pp3/P3B1Q1/1K3P2/R7 w - - 93 90", "4rrk1/1p1nq3/p7/2p1P1pp/3P2bp/3Q1Bn1/PPPB4/1K2R1NR w - - 40 21", "r3k2r/3nnpbp/q2pp1p1/p7/Pp1PPPP1/4BNN1/1P5P/R2Q1RK1 w kq - 0 16", "3Qb1k1/1r2ppb1/pN1n2q1/Pp1Pp1Pr/4P2p/4BP2/4B1R1/1R5K b - - 11 40", // 5-man positions "8/8/8/8/5kp1/P7/8/1K1N4 w - - 0 1", // Kc2 - mate "8/8/8/5N2/8/p7/8/2NK3k w - - 0 1", // Na2 - mate "8/3k4/8/8/8/4B3/4KB2/2B5 w - - 0 1", // draw // 6-man positions "8/8/1P6/5pr1/8/4R3/7k/2K5 w - - 0 1", // Re5 - mate "8/2p4P/8/kr6/6R1/8/8/1K6 w - - 0 1", // Ka2 - mate "8/8/3P3k/8/1p6/8/1P6/1K3n2 b - - 0 1", // Nd2 - draw // 7-man positions "8/R7/2q5/8/6k1/8/1P5p/K6R w - - 0 124", // Draw // Mate and stalemate positions "6k1/3b3r/1p1p4/p1n2p2/1PPNpP1q/P3Q1p1/1R1RB1P1/5K2 b - - 0 1", "r2r1n2/pp2bk2/2p1p2p/3q4/3PN1QP/2P3R1/P4PP1/5RK1 w - - 0 1", "8/8/8/8/8/6k1/6p1/6K1 w - -", "7k/7P/6K1/8/3B4/8/8/8 b - -", // Chess 960 "setoption name UCI_Chess960 value true", "bbqnnrkr/pppppppp/8/8/8/8/PPPPPPPP/BBQNNRKR w KQkq - 0 1 moves g2g3 d7d5 d2d4 c8h3 c1g5 e8d6 g5e7 f7f6", "setoption name UCI_Chess960 value false" }; } // namespace /// setup_bench() builds a list of UCI commands to be run by bench. There /// are five parameters: TT size in MB, number of search threads that /// should be used, the limit value spent for each position, a file name /// where to look for positions in FEN format and the type of the limit: /// depth, perft, nodes and movetime (in millisecs). /// /// bench -> search default positions up to depth 13 /// bench 64 1 15 -> search default positions up to depth 15 (TT = 64MB) /// bench 64 4 5000 current movetime -> search current position with 4 threads for 5 sec /// bench 64 1 100000 default nodes -> search default positions for 100K nodes each /// bench 16 1 5 default perft -> run a perft 5 on default positions vector setup_bench(const Position& current, istream& is) { vector fens, list; string go, token, varname; streampos args = is.tellg(); // Check whether the next token is a variant name if ((is >> token) && variants.find(token) != variants.end()) { args = is.tellg(); varname = token; } else { is.seekg(args); varname = string(Options["UCI_Variant"]); } const Variant* variant = variants.find(varname)->second; // Assign default values to missing arguments string ttSize = (is >> token) ? token : "16"; string threads = (is >> token) ? token : "1"; string limit = (is >> token) ? token : "13"; string fenFile = (is >> token) ? token : "default"; string limitType = (is >> token) ? token : "depth"; go = limitType == "eval" ? "eval" : "go " + limitType + " " + limit; if (fenFile == "default") { if (varname != "chess") fens.push_back(variant->startFen); else fens = Defaults; } else if (fenFile == "current") fens.push_back(current.fen()); else { string fen; ifstream file(fenFile); if (!file.is_open()) { cerr << "Unable to open file " << fenFile << endl; exit(EXIT_FAILURE); } while (getline(file, fen)) if (!fen.empty()) fens.push_back(fen); file.close(); } list.emplace_back("setoption name Threads value " + threads); list.emplace_back("setoption name Hash value " + ttSize); list.emplace_back("setoption name UCI_Variant value " + varname); list.emplace_back("ucinewgame"); for (const string& fen : fens) if (fen.find("setoption") != string::npos) list.emplace_back(fen); else { list.emplace_back("position fen " + fen); list.emplace_back(go); } return list; } Fairy-Stockfish-fairy_sf_11_1/src/bitbase.cpp000066400000000000000000000144531366242550200213240ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include #include "bitboard.h" #include "types.h" namespace { // There are 24 possible pawn squares: files A to D and ranks from 2 to 7. // Positions with the pawn on files E to H will be mirrored before probing. constexpr unsigned MAX_INDEX = 2*24*64*64; // stm * psq * wksq * bksq = 196608 // Each uint32_t stores results of 32 positions, one per bit uint32_t KPKBitbase[MAX_INDEX / 32]; // A KPK bitbase index is an integer in [0, IndexMax] range // // Information is mapped in a way that minimizes the number of iterations: // // bit 0- 5: white king square (from SQ_A1 to SQ_H8) // bit 6-11: black king square (from SQ_A1 to SQ_H8) // bit 12: side to move (WHITE or BLACK) // bit 13-14: white pawn file (from FILE_A to FILE_D) // bit 15-17: white pawn RANK_7 - rank (from RANK_7 - RANK_7 to RANK_7 - RANK_2) unsigned index(Color us, Square bksq, Square wksq, Square psq) { return int(wksq) | (bksq << 6) | (us << 12) | (file_of(psq) << 13) | ((RANK_7 - rank_of(psq)) << 15); } enum Result { INVALID = 0, UNKNOWN = 1, DRAW = 2, WIN = 4 }; Result& operator|=(Result& r, Result v) { return r = Result(r | v); } struct KPKPosition { KPKPosition() = default; explicit KPKPosition(unsigned idx); operator Result() const { return result; } Result classify(const std::vector& db) { return us == WHITE ? classify(db) : classify(db); } template Result classify(const std::vector& db); Color us; Square ksq[COLOR_NB], psq; Result result; }; } // namespace bool Bitbases::probe(Square wksq, Square wpsq, Square bksq, Color us) { assert(file_of(wpsq) <= FILE_D); unsigned idx = index(us, bksq, wksq, wpsq); return KPKBitbase[idx / 32] & (1 << (idx & 0x1F)); } void Bitbases::init() { #ifdef LARGEBOARDS // Bitbases are not working for large-board version return; #endif std::vector db(MAX_INDEX); unsigned idx, repeat = 1; // Initialize db with known win / draw positions for (idx = 0; idx < MAX_INDEX; ++idx) db[idx] = KPKPosition(idx); // Iterate through the positions until none of the unknown positions can be // changed to either wins or draws (15 cycles needed). while (repeat) for (repeat = idx = 0; idx < MAX_INDEX; ++idx) repeat |= (db[idx] == UNKNOWN && db[idx].classify(db) != UNKNOWN); // Map 32 results into one KPKBitbase[] entry for (idx = 0; idx < MAX_INDEX; ++idx) if (db[idx] == WIN) KPKBitbase[idx / 32] |= 1 << (idx & 0x1F); } namespace { KPKPosition::KPKPosition(unsigned idx) { ksq[WHITE] = Square((idx >> 0) & 0x3F); ksq[BLACK] = Square((idx >> 6) & 0x3F); us = Color ((idx >> 12) & 0x01); psq = make_square(File((idx >> 13) & 0x3), Rank(RANK_7 - ((idx >> 15) & 0x7))); // Check if two pieces are on the same square or if a king can be captured if ( distance(ksq[WHITE], ksq[BLACK]) <= 1 || ksq[WHITE] == psq || ksq[BLACK] == psq || (us == WHITE && (PseudoAttacks[WHITE][PAWN][psq] & ksq[BLACK]))) result = INVALID; // Immediate win if a pawn can be promoted without getting captured else if ( us == WHITE && rank_of(psq) == RANK_7 && ksq[us] != psq + NORTH && ( distance(ksq[~us], psq + NORTH) > 1 || (PseudoAttacks[us][KING][ksq[us]] & (psq + NORTH)))) result = WIN; // Immediate draw if it is a stalemate or a king captures undefended pawn else if ( us == BLACK && ( !(PseudoAttacks[us][KING][ksq[us]] & ~(PseudoAttacks[us][KING][ksq[~us]] | PseudoAttacks[~us][PAWN][psq])) || (PseudoAttacks[us][KING][ksq[us]] & psq & ~PseudoAttacks[us][KING][ksq[~us]]))) result = DRAW; // Position will be classified later else result = UNKNOWN; } template Result KPKPosition::classify(const std::vector& db) { // White to move: If one move leads to a position classified as WIN, the result // of the current position is WIN. If all moves lead to positions classified // as DRAW, the current position is classified as DRAW, otherwise the current // position is classified as UNKNOWN. // // Black to move: If one move leads to a position classified as DRAW, the result // of the current position is DRAW. If all moves lead to positions classified // as WIN, the position is classified as WIN, otherwise the current position is // classified as UNKNOWN. constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Result Good = (Us == WHITE ? WIN : DRAW); constexpr Result Bad = (Us == WHITE ? DRAW : WIN); Result r = INVALID; Bitboard b = PseudoAttacks[Us][KING][ksq[Us]]; while (b) r |= Us == WHITE ? db[index(Them, ksq[Them] , pop_lsb(&b), psq)] : db[index(Them, pop_lsb(&b), ksq[Them] , psq)]; if (Us == WHITE) { if (rank_of(psq) < RANK_7) // Single push r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH)]; if ( rank_of(psq) == RANK_2 // Double push && psq + NORTH != ksq[Us] && psq + NORTH != ksq[Them]) r |= db[index(Them, ksq[Them], ksq[Us], psq + NORTH + NORTH)]; } return result = r & Good ? Good : r & UNKNOWN ? UNKNOWN : Bad; } } // namespace Fairy-Stockfish-fairy_sf_11_1/src/bitboard.cpp000066400000000000000000000433671366242550200215070ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include "bitboard.h" #include "magic.h" #include "misc.h" #include "piece.h" uint8_t PopCnt16[1 << 16]; uint8_t SquareDistance[SQUARE_NB][SQUARE_NB]; Bitboard SquareBB[SQUARE_NB]; Bitboard LineBB[SQUARE_NB][SQUARE_NB]; Bitboard PseudoAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Bitboard PseudoMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Bitboard LeaperAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Bitboard LeaperMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; Bitboard BoardSizeBB[FILE_NB][RANK_NB]; RiderType AttackRiderTypes[PIECE_TYPE_NB]; RiderType MoveRiderTypes[PIECE_TYPE_NB]; Magic RookMagicsH[SQUARE_NB]; Magic RookMagicsV[SQUARE_NB]; Magic BishopMagics[SQUARE_NB]; Magic CannonMagicsH[SQUARE_NB]; Magic CannonMagicsV[SQUARE_NB]; Magic HorseMagics[SQUARE_NB]; Magic ElephantMagics[SQUARE_NB]; Magic JanggiElephantMagics[SQUARE_NB]; namespace { #ifdef LARGEBOARDS Bitboard RookTableH[0x11800]; // To store horizontalrook attacks Bitboard RookTableV[0x4800]; // To store vertical rook attacks Bitboard BishopTable[0x33C00]; // To store bishop attacks Bitboard CannonTableH[0x11800]; // To store horizontal cannon attacks Bitboard CannonTableV[0x4800]; // To store vertical cannon attacks Bitboard HorseTable[0x500]; // To store horse attacks Bitboard ElephantTable[0x400]; // To store elephant attacks Bitboard JanggiElephantTable[0x1C000]; // To store janggi elephant attacks #else Bitboard RookTableH[0xA00]; // To store horizontal rook attacks Bitboard RookTableV[0xA00]; // To store vertical rook attacks Bitboard BishopTable[0x1480]; // To store bishop attacks Bitboard CannonTableH[0xA00]; // To store horizontal cannon attacks Bitboard CannonTableV[0xA00]; // To store vertical cannon attacks Bitboard HorseTable[0x240]; // To store horse attacks Bitboard ElephantTable[0x1A0]; // To store elephant attacks Bitboard JanggiElephantTable[0x5C00]; // To store janggi elephant attacks #endif enum MovementType { RIDER, HOPPER, LAME_LEAPER }; template #ifdef PRECOMPUTED_MAGICS void init_magics(Bitboard table[], Magic magics[], std::vector directions, Bitboard magicsInit[]); #else void init_magics(Bitboard table[], Magic magics[], std::vector directions); #endif template Bitboard sliding_attack(std::vector directions, Square sq, Bitboard occupied, Color c = WHITE) { assert(MT != LAME_LEAPER); Bitboard attack = 0; for (Direction d : directions) { bool hurdle = false; for (Square s = sq + (c == WHITE ? d : -d); is_ok(s) && distance(s, s - (c == WHITE ? d : -d)) == 1; s += (c == WHITE ? d : -d)) { if (MT != HOPPER || hurdle) attack |= s; if (occupied & s) { if (MT == HOPPER && !hurdle) hurdle = true; else break; } } } return attack; } Bitboard lame_leaper_path(Direction d, Square s) { Direction dr = d > 0 ? NORTH : SOUTH; Direction df = (std::abs(d % NORTH) < NORTH / 2 ? d % NORTH : -(d % NORTH)) < 0 ? WEST : EAST; Square to = s + d; Bitboard b = 0; if (!is_ok(to) || distance(s, to) >= 4) return b; while (s != to) { int diff = std::abs(file_of(to) - file_of(s)) - std::abs(rank_of(to) - rank_of(s)); if (diff > 0) s += df; else if (diff < 0) s += dr; else s += df + dr; if (s != to) b |= s; } return b; } Bitboard lame_leaper_path(std::vector directions, Square s) { Bitboard b = 0; for (Direction d : directions) b |= lame_leaper_path(d, s); return b; } Bitboard lame_leaper_attack(std::vector directions, Square s, Bitboard occupied) { Bitboard b = 0; for (Direction d : directions) { Square to = s + d; if (is_ok(to) && distance(s, to) < 4 && !(lame_leaper_path(d, s) & occupied)) b |= to; } return b; } } /// Bitboards::pretty() returns an ASCII representation of a bitboard suitable /// to be printed to standard output. Useful for debugging. const std::string Bitboards::pretty(Bitboard b) { std::string s = "+---+---+---+---+---+---+---+---+---+---+---+---+\n"; for (Rank r = RANK_MAX; r >= RANK_1; --r) { for (File f = FILE_A; f <= FILE_MAX; ++f) s += b & make_square(f, r) ? "| X " : "| "; s += "|\n+---+---+---+---+---+---+---+---+---+---+---+---+\n"; } return s; } /// Bitboards::init() initializes various bitboard tables. It is called at /// startup and relies on global objects to be already zero-initialized. void Bitboards::init() { // Piece moves std::vector RookDirectionsV = { NORTH, SOUTH}; std::vector RookDirectionsH = { EAST, WEST }; std::vector BishopDirections = { NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST }; std::vector HorseDirections = {2 * SOUTH + WEST, 2 * SOUTH + EAST, SOUTH + 2 * WEST, SOUTH + 2 * EAST, NORTH + 2 * WEST, NORTH + 2 * EAST, 2 * NORTH + WEST, 2 * NORTH + EAST }; std::vector ElephantDirections = { 2 * NORTH_EAST, 2 * SOUTH_EAST, 2 * SOUTH_WEST, 2 * NORTH_WEST }; std::vector JanggiElephantDirections = { NORTH + 2 * NORTH_EAST, EAST + 2 * NORTH_EAST, EAST + 2 * SOUTH_EAST, SOUTH + 2 * SOUTH_EAST, SOUTH + 2 * SOUTH_WEST, WEST + 2 * SOUTH_WEST, WEST + 2 * NORTH_WEST, NORTH + 2 * NORTH_WEST }; // Initialize rider types for (PieceType pt = PAWN; pt <= KING; ++pt) { const PieceInfo* pi = pieceMap.find(pt)->second; if (pi->lameLeaper) { for (Direction d : pi->stepsCapture) { if (std::find(HorseDirections.begin(), HorseDirections.end(), d) != HorseDirections.end()) AttackRiderTypes[pt] |= RIDER_HORSE; if (std::find(ElephantDirections.begin(), ElephantDirections.end(), d) != ElephantDirections.end()) AttackRiderTypes[pt] |= RIDER_ELEPHANT; if (std::find(JanggiElephantDirections.begin(), JanggiElephantDirections.end(), d) != JanggiElephantDirections.end()) AttackRiderTypes[pt] |= RIDER_JANGGI_ELEPHANT; } for (Direction d : pi->stepsQuiet) { if (std::find(HorseDirections.begin(), HorseDirections.end(), d) != HorseDirections.end()) MoveRiderTypes[pt] |= RIDER_HORSE; if (std::find(ElephantDirections.begin(), ElephantDirections.end(), d) != ElephantDirections.end()) MoveRiderTypes[pt] |= RIDER_ELEPHANT; if (std::find(JanggiElephantDirections.begin(), JanggiElephantDirections.end(), d) != JanggiElephantDirections.end()) MoveRiderTypes[pt] |= RIDER_JANGGI_ELEPHANT; } } for (Direction d : pi->sliderCapture) { if (std::find(BishopDirections.begin(), BishopDirections.end(), d) != BishopDirections.end()) AttackRiderTypes[pt] |= RIDER_BISHOP; if (std::find(RookDirectionsH.begin(), RookDirectionsH.end(), d) != RookDirectionsH.end()) AttackRiderTypes[pt] |= RIDER_ROOK_H; if (std::find(RookDirectionsV.begin(), RookDirectionsV.end(), d) != RookDirectionsV.end()) AttackRiderTypes[pt] |= RIDER_ROOK_V; } for (Direction d : pi->sliderQuiet) { if (std::find(BishopDirections.begin(), BishopDirections.end(), d) != BishopDirections.end()) MoveRiderTypes[pt] |= RIDER_BISHOP; if (std::find(RookDirectionsH.begin(), RookDirectionsH.end(), d) != RookDirectionsH.end()) MoveRiderTypes[pt] |= RIDER_ROOK_H; if (std::find(RookDirectionsV.begin(), RookDirectionsV.end(), d) != RookDirectionsV.end()) MoveRiderTypes[pt] |= RIDER_ROOK_V; } for (Direction d : pi->hopperCapture) { if (std::find(RookDirectionsH.begin(), RookDirectionsH.end(), d) != RookDirectionsH.end()) AttackRiderTypes[pt] |= RIDER_CANNON_H; if (std::find(RookDirectionsV.begin(), RookDirectionsV.end(), d) != RookDirectionsV.end()) AttackRiderTypes[pt] |= RIDER_CANNON_V; } for (Direction d : pi->hopperQuiet) { if (std::find(RookDirectionsH.begin(), RookDirectionsH.end(), d) != RookDirectionsH.end()) MoveRiderTypes[pt] |= RIDER_CANNON_H; if (std::find(RookDirectionsV.begin(), RookDirectionsV.end(), d) != RookDirectionsV.end()) MoveRiderTypes[pt] |= RIDER_CANNON_V; } } for (unsigned i = 0; i < (1 << 16); ++i) PopCnt16[i] = std::bitset<16>(i).count(); for (Square s = SQ_A1; s <= SQ_MAX; ++s) SquareBB[s] = make_bitboard(s); for (File f = FILE_A; f <= FILE_MAX; ++f) for (Rank r = RANK_1; r <= RANK_MAX; ++r) BoardSizeBB[f][r] = forward_file_bb(BLACK, make_square(f, r)) | SquareBB[make_square(f, r)] | (f > FILE_A ? BoardSizeBB[f - 1][r] : Bitboard(0)); for (Square s1 = SQ_A1; s1 <= SQ_MAX; ++s1) for (Square s2 = SQ_A1; s2 <= SQ_MAX; ++s2) SquareDistance[s1][s2] = std::max(distance(s1, s2), distance(s1, s2)); #ifdef PRECOMPUTED_MAGICS init_magics(RookTableH, RookMagicsH, RookDirectionsH, RookMagicHInit); init_magics(RookTableV, RookMagicsV, RookDirectionsV, RookMagicVInit); init_magics(BishopTable, BishopMagics, BishopDirections, BishopMagicInit); init_magics(CannonTableH, CannonMagicsH, RookDirectionsH, CannonMagicHInit); init_magics(CannonTableV, CannonMagicsV, RookDirectionsV, CannonMagicVInit); init_magics(HorseTable, HorseMagics, HorseDirections, HorseMagicInit); init_magics(ElephantTable, ElephantMagics, ElephantDirections, ElephantMagicInit); init_magics(JanggiElephantTable, JanggiElephantMagics, JanggiElephantDirections, JanggiElephantMagicInit); #else init_magics(RookTableH, RookMagicsH, RookDirectionsH); init_magics(RookTableV, RookMagicsV, RookDirectionsV); init_magics(BishopTable, BishopMagics, BishopDirections); init_magics(CannonTableH, CannonMagicsH, RookDirectionsH); init_magics(CannonTableV, CannonMagicsV, RookDirectionsV); init_magics(HorseTable, HorseMagics, HorseDirections); init_magics(ElephantTable, ElephantMagics, ElephantDirections); init_magics(JanggiElephantTable, JanggiElephantMagics, JanggiElephantDirections); #endif for (Color c : { WHITE, BLACK }) for (PieceType pt = PAWN; pt <= KING; ++pt) { const PieceInfo* pi = pieceMap.find(pt)->second; for (Square s = SQ_A1; s <= SQ_MAX; ++s) { for (Direction d : pi->stepsCapture) { Square to = s + Direction(c == WHITE ? d : -d); if (is_ok(to) && distance(s, to) < 4) { PseudoAttacks[c][pt][s] |= to; if (!pi->lameLeaper) LeaperAttacks[c][pt][s] |= to; } } for (Direction d : pi->stepsQuiet) { Square to = s + Direction(c == WHITE ? d : -d); if (is_ok(to) && distance(s, to) < 4) { PseudoMoves[c][pt][s] |= to; if (!pi->lameLeaper) LeaperMoves[c][pt][s] |= to; } } PseudoAttacks[c][pt][s] |= sliding_attack(pi->sliderCapture, s, 0, c); PseudoAttacks[c][pt][s] |= sliding_attack(pi->hopperCapture, s, 0, c); PseudoMoves[c][pt][s] |= sliding_attack(pi->sliderQuiet, s, 0, c); PseudoMoves[c][pt][s] |= sliding_attack(pi->hopperQuiet, s, 0, c); } } for (Square s1 = SQ_A1; s1 <= SQ_MAX; ++s1) { for (PieceType pt : { BISHOP, ROOK }) for (Square s2 = SQ_A1; s2 <= SQ_MAX; ++s2) if (PseudoAttacks[WHITE][pt][s1] & s2) LineBB[s1][s2] = (attacks_bb(WHITE, pt, s1, 0) & attacks_bb(WHITE, pt, s2, 0)) | s1 | s2; } } namespace { // init_magics() computes all rook and bishop attacks at startup. Magic // bitboards are used to look up attacks of sliding pieces. As a reference see // www.chessprogramming.org/Magic_Bitboards. In particular, here we use the so // called "fancy" approach. template #ifdef PRECOMPUTED_MAGICS void init_magics(Bitboard table[], Magic magics[], std::vector directions, Bitboard magicsInit[]) { #else void init_magics(Bitboard table[], Magic magics[], std::vector directions) { #endif // Optimal PRNG seeds to pick the correct magics in the shortest time #ifndef PRECOMPUTED_MAGICS #ifdef LARGEBOARDS int seeds[][RANK_NB] = { { 734, 10316, 55013, 32803, 12281, 15100, 16645, 255, 346, 89123 }, { 734, 10316, 55013, 32803, 12281, 15100, 16645, 255, 346, 89123 } }; #else int seeds[][RANK_NB] = { { 8977, 44560, 54343, 38998, 5731, 95205, 104912, 17020 }, { 728, 10316, 55013, 32803, 12281, 15100, 16645, 255 } }; #endif #endif Bitboard* occupancy = new Bitboard[1 << (FILE_NB + RANK_NB - 4)]; Bitboard* reference = new Bitboard[1 << (FILE_NB + RANK_NB - 4)]; Bitboard edges, b; int* epoch = new int[1 << (FILE_NB + RANK_NB - 4)](); int cnt = 0, size = 0; for (Square s = SQ_A1; s <= SQ_MAX; ++s) { // Board edges are not considered in the relevant occupancies edges = ((Rank1BB | rank_bb(RANK_MAX)) & ~rank_bb(s)) | ((FileABB | file_bb(FILE_MAX)) & ~file_bb(s)); // Given a square 's', the mask is the bitboard of sliding attacks from // 's' computed on an empty board. The index must be big enough to contain // all the attacks for each possible subset of the mask and so is 2 power // the number of 1s of the mask. Hence we deduce the size of the shift to // apply to the 64 or 32 bits word to get the index. Magic& m = magics[s]; m.mask = (MT == LAME_LEAPER ? lame_leaper_path(directions, s) : sliding_attack(directions, s, 0)) & ~edges; #ifdef LARGEBOARDS m.shift = 128 - popcount(m.mask); #else m.shift = (Is64Bit ? 64 : 32) - popcount(m.mask); #endif // Set the offset for the attacks table of the square. We have individual // table sizes for each square with "Fancy Magic Bitboards". m.attacks = s == SQ_A1 ? table : magics[s - 1].attacks + size; // Use Carry-Rippler trick to enumerate all subsets of masks[s] and // store the corresponding sliding attack bitboard in reference[]. b = size = 0; do { occupancy[size] = b; reference[size] = MT == LAME_LEAPER ? lame_leaper_attack(directions, s, b) : sliding_attack(directions, s, b); if (HasPext) m.attacks[pext(b, m.mask)] = reference[size]; size++; b = (b - m.mask) & m.mask; } while (b); if (HasPext) continue; #ifndef PRECOMPUTED_MAGICS PRNG rng(seeds[Is64Bit][rank_of(s)]); #endif // Find a magic for square 's' picking up an (almost) random number // until we find the one that passes the verification test. for (int i = 0; i < size; ) { for (m.magic = 0; popcount((m.magic * m.mask) >> (SQUARE_NB - FILE_NB)) < FILE_NB - 2; ) { #ifdef LARGEBOARDS #ifdef PRECOMPUTED_MAGICS m.magic = magicsInit[s]; #else m.magic = (rng.sparse_rand() << 64) ^ rng.sparse_rand(); #endif #else m.magic = rng.sparse_rand(); #endif } // A good magic must map every possible occupancy to an index that // looks up the correct sliding attack in the attacks[s] database. // Note that we build up the database for square 's' as a side // effect of verifying the magic. Keep track of the attempt count // and save it in epoch[], little speed-up trick to avoid resetting // m.attacks[] after every failed attempt. for (++cnt, i = 0; i < size; ++i) { unsigned idx = m.index(occupancy[i]); if (epoch[idx] < cnt) { epoch[idx] = cnt; m.attacks[idx] = reference[i]; } else if (m.attacks[idx] != reference[i]) break; } } } delete[] occupancy; delete[] reference; delete[] epoch; } } Fairy-Stockfish-fairy_sf_11_1/src/bitboard.h000066400000000000000000000471211366242550200211440ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef BITBOARD_H_INCLUDED #define BITBOARD_H_INCLUDED #include #include "types.h" namespace Bitbases { void init(); bool probe(Square wksq, Square wpsq, Square bksq, Color us); } namespace Bitboards { void init(); const std::string pretty(Bitboard b); } #ifdef LARGEBOARDS constexpr Bitboard AllSquares = ((~Bitboard(0)) >> 8); #else constexpr Bitboard AllSquares = ~Bitboard(0); #endif #ifdef LARGEBOARDS constexpr Bitboard DarkSquares = (Bitboard(0xAAA555AAA555AAULL) << 64) ^ Bitboard(0xA555AAA555AAA555ULL); #else constexpr Bitboard DarkSquares = 0xAA55AA55AA55AA55ULL; #endif #ifdef LARGEBOARDS constexpr Bitboard FileABB = (Bitboard(0x00100100100100ULL) << 64) ^ Bitboard(0x1001001001001001ULL); #else constexpr Bitboard FileABB = 0x0101010101010101ULL; #endif constexpr Bitboard FileBBB = FileABB << 1; constexpr Bitboard FileCBB = FileABB << 2; constexpr Bitboard FileDBB = FileABB << 3; constexpr Bitboard FileEBB = FileABB << 4; constexpr Bitboard FileFBB = FileABB << 5; constexpr Bitboard FileGBB = FileABB << 6; constexpr Bitboard FileHBB = FileABB << 7; #ifdef LARGEBOARDS constexpr Bitboard FileIBB = FileABB << 8; constexpr Bitboard FileJBB = FileABB << 9; constexpr Bitboard FileKBB = FileABB << 10; constexpr Bitboard FileLBB = FileABB << 11; #endif #ifdef LARGEBOARDS constexpr Bitboard Rank1BB = 0xFFF; #else constexpr Bitboard Rank1BB = 0xFF; #endif constexpr Bitboard Rank2BB = Rank1BB << (FILE_NB * 1); constexpr Bitboard Rank3BB = Rank1BB << (FILE_NB * 2); constexpr Bitboard Rank4BB = Rank1BB << (FILE_NB * 3); constexpr Bitboard Rank5BB = Rank1BB << (FILE_NB * 4); constexpr Bitboard Rank6BB = Rank1BB << (FILE_NB * 5); constexpr Bitboard Rank7BB = Rank1BB << (FILE_NB * 6); constexpr Bitboard Rank8BB = Rank1BB << (FILE_NB * 7); #ifdef LARGEBOARDS constexpr Bitboard Rank9BB = Rank1BB << (FILE_NB * 8); constexpr Bitboard Rank10BB = Rank1BB << (FILE_NB * 9); #endif constexpr Bitboard QueenSide = FileABB | FileBBB | FileCBB | FileDBB; constexpr Bitboard CenterFiles = FileCBB | FileDBB | FileEBB | FileFBB; constexpr Bitboard KingSide = FileEBB | FileFBB | FileGBB | FileHBB; constexpr Bitboard Center = (FileDBB | FileEBB) & (Rank4BB | Rank5BB); constexpr Bitboard KingFlank[FILE_NB] = { QueenSide ^ FileDBB, QueenSide, QueenSide, CenterFiles, CenterFiles, KingSide, KingSide, KingSide ^ FileEBB }; extern uint8_t PopCnt16[1 << 16]; extern uint8_t SquareDistance[SQUARE_NB][SQUARE_NB]; extern Bitboard SquareBB[SQUARE_NB]; extern Bitboard LineBB[SQUARE_NB][SQUARE_NB]; extern Bitboard PseudoAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; extern Bitboard PseudoMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; extern Bitboard LeaperAttacks[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; extern Bitboard LeaperMoves[COLOR_NB][PIECE_TYPE_NB][SQUARE_NB]; extern Bitboard SquareBB[SQUARE_NB]; extern Bitboard BoardSizeBB[FILE_NB][RANK_NB]; extern RiderType AttackRiderTypes[PIECE_TYPE_NB]; extern RiderType MoveRiderTypes[PIECE_TYPE_NB]; #ifdef LARGEBOARDS int popcount(Bitboard b); // required for 128 bit pext #endif /// Magic holds all magic bitboards relevant data for a single square struct Magic { Bitboard mask; Bitboard magic; Bitboard* attacks; unsigned shift; // Compute the attack's index using the 'magic bitboards' approach unsigned index(Bitboard occupied) const { if (HasPext) return unsigned(pext(occupied, mask)); #ifndef LARGEBOARDS if (Is64Bit) #endif return unsigned(((occupied & mask) * magic) >> shift); unsigned lo = unsigned(occupied) & unsigned(mask); unsigned hi = unsigned(occupied >> 32) & unsigned(mask >> 32); return (lo * unsigned(magic) ^ hi * unsigned(magic >> 32)) >> shift; } }; extern Magic RookMagicsH[SQUARE_NB]; extern Magic RookMagicsV[SQUARE_NB]; extern Magic BishopMagics[SQUARE_NB]; extern Magic CannonMagicsH[SQUARE_NB]; extern Magic CannonMagicsV[SQUARE_NB]; extern Magic HorseMagics[SQUARE_NB]; extern Magic ElephantMagics[SQUARE_NB]; extern Magic JanggiElephantMagics[SQUARE_NB]; inline Bitboard square_bb(Square s) { assert(s >= SQ_A1 && s <= SQ_MAX); return SquareBB[s]; } /// Overloads of bitwise operators between a Bitboard and a Square for testing /// whether a given bit is set in a bitboard, and for setting and clearing bits. inline Bitboard operator&( Bitboard b, Square s) { return b & square_bb(s); } inline Bitboard operator|( Bitboard b, Square s) { return b | square_bb(s); } inline Bitboard operator^( Bitboard b, Square s) { return b ^ square_bb(s); } inline Bitboard& operator|=(Bitboard& b, Square s) { return b |= square_bb(s); } inline Bitboard& operator^=(Bitboard& b, Square s) { return b ^= square_bb(s); } inline Bitboard operator-( Bitboard b, Square s) { return b & ~square_bb(s); } inline Bitboard& operator-=(Bitboard& b, Square s) { return b &= ~square_bb(s); } inline Bitboard operator&(Square s, Bitboard b) { return b & s; } inline Bitboard operator|(Square s, Bitboard b) { return b | s; } inline Bitboard operator^(Square s, Bitboard b) { return b ^ s; } inline Bitboard operator|(Square s, Square s2) { return square_bb(s) | square_bb(s2); } constexpr bool more_than_one(Bitboard b) { return b & (b - 1); } /// board_size_bb() returns a bitboard representing all the squares /// on a board with given size. inline Bitboard board_size_bb(File f, Rank r) { return BoardSizeBB[f][r]; } inline bool opposite_colors(Square s1, Square s2) { return bool(DarkSquares & s1) != bool(DarkSquares & s2); } /// rank_bb() and file_bb() return a bitboard representing all the squares on /// the given file or rank. inline Bitboard rank_bb(Rank r) { return Rank1BB << (FILE_NB * r); } inline Bitboard rank_bb(Square s) { return rank_bb(rank_of(s)); } inline Bitboard file_bb(File f) { return FileABB << f; } inline Bitboard file_bb(Square s) { return file_bb(file_of(s)); } /// make_bitboard() returns a bitboard from a list of squares constexpr Bitboard make_bitboard() { return 0; } template constexpr Bitboard make_bitboard(Square s, Squares... squares) { return (Bitboard(1) << s) | make_bitboard(squares...); } /// shift() moves a bitboard one step along direction D template constexpr Bitboard shift(Bitboard b) { return D == NORTH ? b << NORTH : D == SOUTH ? b >> NORTH : D == NORTH+NORTH? b <<(2 * NORTH) : D == SOUTH+SOUTH? b >> (2 * NORTH) : D == EAST ? (b & ~file_bb(FILE_MAX)) << EAST : D == WEST ? (b & ~FileABB) >> EAST : D == NORTH_EAST ? (b & ~file_bb(FILE_MAX)) << NORTH_EAST : D == NORTH_WEST ? (b & ~FileABB) << NORTH_WEST : D == SOUTH_EAST ? (b & ~file_bb(FILE_MAX)) >> NORTH_WEST : D == SOUTH_WEST ? (b & ~FileABB) >> NORTH_EAST : Bitboard(0); } /// shift() moves a bitboard one step along direction D (mainly for pawns) constexpr Bitboard shift(Direction D, Bitboard b) { return D == NORTH ? b << NORTH : D == SOUTH ? b >> NORTH : D == NORTH+NORTH? b <<(2 * NORTH) : D == SOUTH+SOUTH? b >> (2 * NORTH) : D == EAST ? (b & ~file_bb(FILE_MAX)) << EAST : D == WEST ? (b & ~FileABB) >> EAST : D == NORTH_EAST ? (b & ~file_bb(FILE_MAX)) << NORTH_EAST : D == NORTH_WEST ? (b & ~FileABB) << NORTH_WEST : D == SOUTH_EAST ? (b & ~file_bb(FILE_MAX)) >> NORTH_WEST : D == SOUTH_WEST ? (b & ~FileABB) >> NORTH_EAST : Bitboard(0); } /// pawn_attacks_bb() returns the squares attacked by pawns of the given color /// from the squares in the given bitboard. template constexpr Bitboard pawn_attacks_bb(Bitboard b) { return C == WHITE ? shift(b) | shift(b) : shift(b) | shift(b); } /// pawn_double_attacks_bb() returns the squares doubly attacked by pawns of the /// given color from the squares in the given bitboard. template constexpr Bitboard pawn_double_attacks_bb(Bitboard b) { return C == WHITE ? shift(b) & shift(b) : shift(b) & shift(b); } /// adjacent_files_bb() returns a bitboard representing all the squares on the /// adjacent files of the given one. inline Bitboard adjacent_files_bb(Square s) { return shift(file_bb(s)) | shift(file_bb(s)); } /// between_bb() returns squares that are linearly between the given squares /// If the given squares are not on a same file/rank/diagonal, return 0. inline Bitboard between_bb(Square s1, Square s2) { return LineBB[s1][s2] & ( (AllSquares << (s1 + (s1 < s2))) ^(AllSquares << (s2 + !(s1 < s2)))); } inline Bitboard between_bb(Square s1, Square s2, PieceType pt) { if (pt == HORSE) return PseudoAttacks[WHITE][WAZIR][s2] & PseudoAttacks[WHITE][FERS][s1]; else if (pt == JANGGI_ELEPHANT) return (PseudoAttacks[WHITE][WAZIR][s2] & PseudoAttacks[WHITE][ALFIL][s1]) | (PseudoAttacks[WHITE][KNIGHT][s2] & PseudoAttacks[WHITE][FERS][s1]); else return between_bb(s1, s2); } /// forward_ranks_bb() returns a bitboard representing the squares on the ranks /// in front of the given one, from the point of view of the given color. For instance, /// forward_ranks_bb(BLACK, SQ_D3) will return the 16 squares on ranks 1 and 2. inline Bitboard forward_ranks_bb(Color c, Square s) { return c == WHITE ? (AllSquares ^ Rank1BB) << FILE_NB * (rank_of(s) - RANK_1) : (AllSquares ^ rank_bb(RANK_MAX)) >> FILE_NB * (RANK_MAX - rank_of(s)); } inline Bitboard forward_ranks_bb(Color c, Rank r) { return c == WHITE ? (AllSquares ^ Rank1BB) << FILE_NB * (r - RANK_1) : (AllSquares ^ rank_bb(RANK_MAX)) >> FILE_NB * (RANK_MAX - r); } /// promotion_zone_bb() returns a bitboard representing the squares on all the ranks /// in front of and on the given relative rank, from the point of view of the given color. /// For instance, promotion_zone_bb(BLACK, RANK_7) will return the 16 squares on ranks 1 and 2. inline Bitboard promotion_zone_bb(Color c, Rank r, Rank maxRank) { return forward_ranks_bb(c, relative_rank(c, r, maxRank)) | rank_bb(relative_rank(c, r, maxRank)); } /// forward_file_bb() returns a bitboard representing all the squares along the /// line in front of the given one, from the point of view of the given color. inline Bitboard forward_file_bb(Color c, Square s) { return forward_ranks_bb(c, s) & file_bb(s); } /// pawn_attack_span() returns a bitboard representing all the squares that can /// be attacked by a pawn of the given color when it moves along its file, /// starting from the given square. inline Bitboard pawn_attack_span(Color c, Square s) { return forward_ranks_bb(c, s) & adjacent_files_bb(s); } /// passed_pawn_span() returns a bitboard which can be used to test if a pawn of /// the given color and on the given square is a passed pawn. inline Bitboard passed_pawn_span(Color c, Square s) { return forward_ranks_bb(c, s) & (adjacent_files_bb(s) | file_bb(s)); } /// aligned() returns true if the squares s1, s2 and s3 are aligned either on a /// straight or on a diagonal line. inline bool aligned(Square s1, Square s2, Square s3) { return LineBB[s1][s2] & s3; } /// distance() functions return the distance between x and y, defined as the /// number of steps for a king in x to reach y. template inline int distance(Square x, Square y); template<> inline int distance(Square x, Square y) { return std::abs(file_of(x) - file_of(y)); } template<> inline int distance(Square x, Square y) { return std::abs(rank_of(x) - rank_of(y)); } template<> inline int distance(Square x, Square y) { return SquareDistance[x][y]; } template constexpr const T& clamp(const T& v, const T& lo, const T& hi) { return v < lo ? lo : v > hi ? hi : v; } template inline Bitboard rider_attacks_bb(Square s, Bitboard occupied) { assert(R == RIDER_BISHOP || R == RIDER_ROOK_H || R == RIDER_ROOK_V || R == RIDER_CANNON_H || R == RIDER_CANNON_V || R == RIDER_HORSE || R == RIDER_ELEPHANT || R == RIDER_JANGGI_ELEPHANT); const Magic& m = R == RIDER_ROOK_H ? RookMagicsH[s] : R == RIDER_ROOK_V ? RookMagicsV[s] : R == RIDER_CANNON_H ? CannonMagicsH[s] : R == RIDER_CANNON_V ? CannonMagicsV[s] : R == RIDER_HORSE ? HorseMagics[s] : R == RIDER_ELEPHANT ? ElephantMagics[s] : R == RIDER_JANGGI_ELEPHANT ? JanggiElephantMagics[s] : BishopMagics[s]; return m.attacks[m.index(occupied)]; } /// attacks_bb() returns a bitboard representing all the squares attacked by a /// piece of type Pt (bishop or rook) placed on 's'. template inline Bitboard attacks_bb(Square s, Bitboard occupied) { assert(Pt == BISHOP || Pt == ROOK); return Pt == BISHOP ? rider_attacks_bb(s, occupied) : rider_attacks_bb(s, occupied) | rider_attacks_bb(s, occupied); } inline Bitboard attacks_bb(Color c, PieceType pt, Square s, Bitboard occupied) { Bitboard b = LeaperAttacks[c][pt][s]; if (AttackRiderTypes[pt] & RIDER_BISHOP) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_ROOK_H) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_ROOK_V) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_CANNON_H) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_CANNON_V) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_HORSE) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_ELEPHANT) b |= rider_attacks_bb(s, occupied); if (AttackRiderTypes[pt] & RIDER_JANGGI_ELEPHANT) b |= rider_attacks_bb(s, occupied); return b & PseudoAttacks[c][pt][s]; } inline Bitboard moves_bb(Color c, PieceType pt, Square s, Bitboard occupied) { Bitboard b = LeaperMoves[c][pt][s]; if (MoveRiderTypes[pt] & RIDER_BISHOP) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_ROOK_H) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_ROOK_V) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_CANNON_H) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_CANNON_V) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_HORSE) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_ELEPHANT) b |= rider_attacks_bb(s, occupied); if (MoveRiderTypes[pt] & RIDER_JANGGI_ELEPHANT) b |= rider_attacks_bb(s, occupied); return b & PseudoMoves[c][pt][s]; } /// popcount() counts the number of non-zero bits in a bitboard inline int popcount(Bitboard b) { #ifndef USE_POPCNT #ifdef LARGEBOARDS union { Bitboard bb; uint16_t u[8]; } v = { b }; return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]] + PopCnt16[v.u[4]] + PopCnt16[v.u[5]] + PopCnt16[v.u[6]] + PopCnt16[v.u[7]]; #else union { Bitboard bb; uint16_t u[4]; } v = { b }; return PopCnt16[v.u[0]] + PopCnt16[v.u[1]] + PopCnt16[v.u[2]] + PopCnt16[v.u[3]]; #endif #elif defined(_MSC_VER) || defined(__INTEL_COMPILER) #ifdef LARGEBOARDS return (int)_mm_popcnt_u64(uint64_t(b >> 64)) + (int)_mm_popcnt_u64(uint64_t(b)); #else return (int)_mm_popcnt_u64(b); #endif #else // Assumed gcc or compatible compiler #ifdef LARGEBOARDS return __builtin_popcountll(b >> 64) + __builtin_popcountll(b); #else return __builtin_popcountll(b); #endif #endif } /// lsb() and msb() return the least/most significant bit in a non-zero bitboard #if defined(__GNUC__) // GCC, Clang, ICC inline Square lsb(Bitboard b) { assert(b); #ifdef LARGEBOARDS if (!(b << 64)) return Square(__builtin_ctzll(b >> 64) + 64); #endif return Square(__builtin_ctzll(b)); } inline Square msb(Bitboard b) { assert(b); #ifdef LARGEBOARDS if (b >> 64) return Square(int(SQUARE_BIT_MASK) ^ __builtin_clzll(b >> 64)); return Square(int(SQUARE_BIT_MASK) ^ (__builtin_clzll(b) + 64)); #else return Square(int(SQUARE_BIT_MASK) ^ __builtin_clzll(b)); #endif } #elif defined(_MSC_VER) // MSVC #ifdef _WIN64 // MSVC, WIN64 inline Square lsb(Bitboard b) { assert(b); unsigned long idx; #ifdef LARGEBOARDS if (uint64_t(b)) { _BitScanForward64(&idx, uint64_t(b)); return Square(idx); } else { _BitScanForward64(&idx, uint64_t(b >> 64)); return Square(idx + 64); } #else _BitScanForward64(&idx, b); return (Square) idx; #endif } inline Square msb(Bitboard b) { assert(b); unsigned long idx; #ifdef LARGEBOARDS if (b >> 64) { _BitScanReverse64(&idx, uint64_t(b >> 64)); return Square(idx + 64); } else { _BitScanReverse64(&idx, uint64_t(b)); return Square(idx); } #else _BitScanReverse64(&idx, b); return (Square) idx; #endif } #else // MSVC, WIN32 inline Square lsb(Bitboard b) { assert(b); unsigned long idx; #ifdef LARGEBOARDS if (b << 96) { _BitScanForward(&idx, uint32_t(b)); return Square(idx); } else if (b << 64) { _BitScanForward(&idx, uint32_t(b >> 32)); return Square(idx + 32); } else if (b << 32) { _BitScanForward(&idx, uint32_t(b >> 64)); return Square(idx + 64); } else { _BitScanForward(&idx, uint32_t(b >> 96)); return Square(idx + 96); } #else if (b & 0xffffffff) { _BitScanForward(&idx, uint32_t(b)); return Square(idx); } else { _BitScanForward(&idx, uint32_t(b >> 32)); return Square(idx + 32); } #endif } inline Square msb(Bitboard b) { assert(b); unsigned long idx; #ifdef LARGEBOARDS if (b >> 96) { _BitScanReverse(&idx, uint32_t(b >> 96)); return Square(idx + 96); } else if (b >> 64) { _BitScanReverse(&idx, uint32_t(b >> 64)); return Square(idx + 64); } else #endif if (b >> 32) { _BitScanReverse(&idx, uint32_t(b >> 32)); return Square(idx + 32); } else { _BitScanReverse(&idx, uint32_t(b)); return Square(idx); } } #endif #else // Compiler is neither GCC nor MSVC compatible #error "Compiler not supported." #endif /// pop_lsb() finds and clears the least significant bit in a non-zero bitboard inline Square pop_lsb(Bitboard* b) { const Square s = lsb(*b); *b &= *b - 1; return s; } /// frontmost_sq() returns the most advanced square for the given color inline Square frontmost_sq(Color c, Bitboard b) { return c == WHITE ? msb(b) : lsb(b); } #endif // #ifndef BITBOARD_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/endgame.cpp000066400000000000000000001102211366242550200213010ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include "bitboard.h" #include "endgame.h" #include "movegen.h" using std::string; namespace { // Table used to drive the king towards the edge of the board // in KX vs K and KQ vs KR endgames. constexpr int PushToEdges[SQUARE_NB] = { 100, 90, 80, 70, 70, 80, 90, 100, 90, 70, 60, 50, 50, 60, 70, 90, 80, 60, 40, 30, 30, 40, 60, 80, 70, 50, 30, 20, 20, 30, 50, 70, 70, 50, 30, 20, 20, 30, 50, 70, 80, 60, 40, 30, 30, 40, 60, 80, 90, 70, 60, 50, 50, 60, 70, 90, 100, 90, 80, 70, 70, 80, 90, 100 }; // Table used to drive the king towards a corner square of the // right color in KBN vs K endgames. constexpr int PushToCorners[SQUARE_NB] = { 6400, 6080, 5760, 5440, 5120, 4800, 4480, 4160, 6080, 5760, 5440, 5120, 4800, 4480, 4160, 4480, 5760, 5440, 4960, 4480, 4480, 4000, 4480, 4800, 5440, 5120, 4480, 3840, 3520, 4480, 4800, 5120, 5120, 4800, 4480, 3520, 3840, 4480, 5120, 5440, 4800, 4480, 4000, 4480, 4480, 4960, 5440, 5760, 4480, 4160, 4480, 4800, 5120, 5440, 5760, 6080, 4160, 4480, 4800, 5120, 5440, 5760, 6080, 6400 }; // Table used to drive the king towards the edge of the board // in KSF vs K. constexpr int PushToOpposingSideEdges[SQUARE_NB] = { 30, 10, 5, 0, 0, 5, 10, 30, 40, 20, 5, 0, 0, 5, 20, 40, 50, 30, 10, 0, 0, 10, 30, 50, 60, 40, 20, 10, 10, 20, 40, 60, 70, 50, 30, 20, 20, 30, 50, 70, 80, 60, 40, 30, 30, 40, 60, 80, 90, 70, 60, 50, 50, 60, 70, 90, 100, 90, 80, 70, 70, 80, 90, 100 }; // Tables used to drive a piece towards or away from another piece constexpr int PushClose[FILE_NB] = { 0, 0, 100, 80, 60, 40, 20, 10 }; constexpr int PushAway [FILE_NB] = { 0, 5, 20, 40, 60, 80, 90, 100 }; // Pawn Rank based scaling factors used in KRPPKRP endgame constexpr int KRPPKRPScaleFactors[RANK_NB] = { 0, 9, 10, 14, 21, 44, 0, 0 }; #ifndef NDEBUG bool verify_material(const Position& pos, Color c, Value npm, int pawnsCnt) { return pos.non_pawn_material(c) == npm && pos.count(c) == pawnsCnt; } #endif // Map the square as if strongSide is white and strongSide's only pawn // is on the left half of the board. Square normalize(const Position& pos, Color strongSide, Square sq) { assert(pos.count(strongSide) == 1); if (file_of(pos.square(strongSide)) > pos.max_file() / 2) sq = Square(sq + pos.max_file() - 2 * file_of(sq)); // Mirror SQ_H1 -> SQ_A1 return relative_square(strongSide, sq, pos.max_rank()); } // Map the square to an 8x8 board Square map_to_standard_board(const Position& pos, Square s) { File f = file_of(s) > pos.max_file() / 2 ? File(FILE_H - pos.max_file() + file_of(s)) : file_of(s); Rank r = rank_of(s) > pos.max_rank() / 2 ? Rank(RANK_8 - pos.max_rank() + rank_of(s)) : rank_of(s); return Square(r * 8 + f); } } // namespace namespace Endgames { std::pair, Map> maps; void init() { add("KPK"); add("KNNK"); add("KBNK"); add("KRKP"); add("KRKB"); add("KRKN"); add("KQKP"); add("KQKR"); add("KNNKP"); // Fairy piece endgames add("KNSK"); add("KNFK"); add("KNSFKR"); add("KSFK"); add("KNPK"); add("KNPKB"); add("KRPKR"); add("KRPKB"); add("KBPKB"); add("KBPKN"); add("KBPPKB"); add("KRPPKRP"); } } /// Mate with KX vs K. This function is used to evaluate positions with /// king and plenty of material vs a lone king. It simply gives the /// attacking side a bonus for driving the defending king towards the edge /// of the board, and for keeping the distance between the two kings small. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); assert(!pos.checkers()); // Eval is never called when in check // Stalemate detection with lone king if (pos.side_to_move() == weakSide && !MoveList(pos).size()) return VALUE_DRAW; Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Value result = pos.non_pawn_material(strongSide) + pos.count(strongSide) * PawnValueEg + PushToEdges[map_to_standard_board(pos, loserKSq)] + PushClose[distance(winnerKSq, loserKSq)]; if ( pos.count(strongSide) || pos.count(strongSide) ||(pos.count(strongSide) && pos.count(strongSide)) || ( (pos.pieces(strongSide, BISHOP) & ~DarkSquares) && (pos.pieces(strongSide, BISHOP) & DarkSquares)) || pos.count(strongSide) >= 2 ||(pos.count(strongSide) && pos.count(strongSide)) ||(pos.count(strongSide) && pos.count(strongSide)) ||(pos.count(strongSide) && pos.count(strongSide) >= 2) ||(pos.count(strongSide) >= 3 && ( DarkSquares & pos.pieces(strongSide, FERS)) && (~DarkSquares & pos.pieces(strongSide, FERS)))) result = std::min(result + VALUE_KNOWN_WIN, VALUE_MATE_IN_MAX_PLY - 1); return strongSide == pos.side_to_move() ? result : -result; } /// Mate with KBN vs K. This is similar to KX vs K, but we have to drive the /// defending king towards a corner square that our bishop attacks. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg + BishopValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Square bishopSq = pos.square(strongSide); // If our bishop does not attack A1/H8, we flip the enemy king square // to drive to opposite corners (A8/H1). Value result = VALUE_KNOWN_WIN + PushClose[distance(winnerKSq, loserKSq)] + PushToCorners[map_to_standard_board(pos, relative_square(opposite_colors(bishopSq, SQ_A1) ? BLACK : WHITE, loserKSq, pos.max_rank()))]; assert(abs(result) < VALUE_MATE_IN_MAX_PLY); return strongSide == pos.side_to_move() ? result : -result; } /// KP vs K. This endgame is evaluated with the help of a bitbase template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, VALUE_ZERO, 1)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); // Assume strongSide is white and the pawn is on files A-D Square wksq = normalize(pos, strongSide, pos.square(strongSide)); Square bksq = normalize(pos, strongSide, pos.square(weakSide)); Square psq = normalize(pos, strongSide, pos.square(strongSide)); Color us = strongSide == pos.side_to_move() ? WHITE : BLACK; Value result; if ( pos.promotion_rank() == RANK_8 && RANK_MAX == RANK_8 && pos.promotion_piece_types().find(QUEEN) != pos.promotion_piece_types().end()) { if (!Bitbases::probe(wksq, psq, bksq, us)) return VALUE_DRAW; result = VALUE_KNOWN_WIN + PawnValueEg + Value(rank_of(psq)); } else { // Non-standard promotion, evaluation unclear result = PawnValueEg + Value(rank_of(psq)); } return strongSide == pos.side_to_move() ? result : -result; } /// KR vs KP. This is a somewhat tricky endgame to evaluate precisely without /// a bitbase. The function below returns drawish scores when the pawn is /// far advanced with support of the king, while the attacking king is far /// away. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); Square wksq = relative_square(strongSide, pos.square(strongSide)); Square bksq = relative_square(strongSide, pos.square(weakSide)); Square rsq = relative_square(strongSide, pos.square(strongSide)); Square psq = relative_square(strongSide, pos.square(weakSide)); Square queeningSq = make_square(file_of(psq), RANK_1); Value result; // If the stronger side's king is in front of the pawn, it's a win if (forward_file_bb(WHITE, wksq) & psq) result = RookValueEg - distance(wksq, psq); // If the weaker side's king is too far from the pawn and the rook, // it's a win. else if ( distance(bksq, psq) >= 3 + (pos.side_to_move() == weakSide) && distance(bksq, rsq) >= 3) result = RookValueEg - distance(wksq, psq); // If the pawn is far advanced and supported by the defending king, // the position is drawish else if ( rank_of(bksq) <= RANK_3 && distance(bksq, psq) == 1 && rank_of(wksq) >= RANK_4 && distance(wksq, psq) > 2 + (pos.side_to_move() == strongSide)) result = Value(80) - 8 * distance(wksq, psq); else result = Value(200) - 8 * ( distance(wksq, psq + SOUTH) - distance(bksq, psq + SOUTH) - distance(psq, queeningSq)); return strongSide == pos.side_to_move() ? result : -result; } /// KR vs KB. This is very simple, and always returns drawish scores. The /// score is slightly bigger when the defending king is close to the edge. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 0)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); Value result = Value(PushToEdges[map_to_standard_board(pos, pos.square(weakSide))]); return strongSide == pos.side_to_move() ? result : -result; } /// KR vs KN. The attacking side has slightly better winning chances than /// in KR vs KB, particularly if the king and the knight are far apart. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 0)); assert(verify_material(pos, weakSide, KnightValueMg, 0)); Square bksq = pos.square(weakSide); Square bnsq = pos.square(weakSide); Value result = Value(PushToEdges[map_to_standard_board(pos, bksq)] + PushAway[distance(bksq, bnsq)]); return strongSide == pos.side_to_move() ? result : -result; } /// KQ vs KP. In general, this is a win for the stronger side, but there are a /// few important exceptions. A pawn on 7th rank and on the A,C,F or H files /// with a king positioned next to it can be a draw, so in that case, we only /// use the distance between the kings. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, QueenValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Square pawnSq = pos.square(weakSide); Value result = Value(PushClose[distance(winnerKSq, loserKSq)]); if ( relative_rank(weakSide, pawnSq) != RANK_7 || distance(loserKSq, pawnSq) != 1 || !((FileABB | FileCBB | FileFBB | FileHBB) & pawnSq)) result += QueenValueEg - PawnValueEg; return strongSide == pos.side_to_move() ? result : -result; } /// KQ vs KR. This is almost identical to KX vs K: We give the attacking /// king a bonus for having the kings close together, and for forcing the /// defending king towards the edge. If we also take care to avoid null move for /// the defending side in the search, this is usually sufficient to win KQ vs KR. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, QueenValueMg, 0)); assert(verify_material(pos, weakSide, RookValueMg, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Value result = QueenValueEg - RookValueEg + PushToEdges[map_to_standard_board(pos, loserKSq)] + PushClose[distance(winnerKSq, loserKSq)]; return strongSide == pos.side_to_move() ? result : -result; } /// KNN vs KP. Simply push the opposing king to the corner template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, 2 * KnightValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); Value result = 2 * KnightValueEg - PawnValueEg + PushToEdges[map_to_standard_board(pos, pos.square(weakSide))]; return strongSide == pos.side_to_move() ? result : -result; } /// Some cases of trivial draws template<> Value Endgame::operator()(const Position&) const { return VALUE_DRAW; } /// KFsPs vs K. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Value result = pos.non_pawn_material(strongSide) + pos.count(strongSide) * PawnValueEg + PushToEdges[map_to_standard_board(pos, loserKSq)] + PushClose[distance(winnerKSq, loserKSq)]; if ( pos.count(strongSide) >= 3 && ( DarkSquares & pos.pieces(strongSide, FERS)) && (~DarkSquares & pos.pieces(strongSide, FERS))) result = std::min(result + VALUE_KNOWN_WIN, VALUE_MATE_IN_MAX_PLY - 1); else if (pos.count(strongSide) + pos.count(strongSide) < 3) return VALUE_DRAW; else { bool dark = DarkSquares & pos.pieces(strongSide, FERS); bool light = ~DarkSquares & pos.pieces(strongSide, FERS); // Determine the color of ferzes from promoting pawns Bitboard b = pos.pieces(strongSide, PAWN); while (b && (!dark || !light)) { if (file_of(pop_lsb(&b)) % 2 != relative_rank(strongSide, pos.promotion_rank(), pos.max_rank()) % 2) light = true; else dark = true; } if (!dark || !light) return VALUE_DRAW; // we can not checkmate with same colored ferzes } return strongSide == pos.side_to_move() ? result : -result; } /// Mate with KNS vs K. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg + SilverValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Value result = VALUE_KNOWN_WIN + PushClose[distance(winnerKSq, loserKSq)] + PushToOpposingSideEdges[map_to_standard_board(pos, relative_square(strongSide, loserKSq, pos.max_rank()))]; return strongSide == pos.side_to_move() ? result : -result; } /// KNF vs K. Can only be won if the weaker side's king /// is close to a corner of the same color as the fers. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg + FersValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Square fersSq = pos.square(strongSide); // tries to drive toward corners A1 or H8. If we have a // fers that cannot reach the above squares, we flip the kings in order // to drive the enemy toward corners A8 or H1. if (opposite_colors(fersSq, SQ_A1)) { winnerKSq = relative_square(BLACK, winnerKSq, pos.max_rank()); loserKSq = relative_square(BLACK, loserKSq, pos.max_rank()); } Value result = Value(PushClose[distance(winnerKSq, loserKSq)]) + PushToCorners[map_to_standard_board(pos, loserKSq)] / 10; return strongSide == pos.side_to_move() ? result : -result; } /// KNSFKR vs K. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg + SilverValueMg + FersValueMg, 0)); assert(verify_material(pos, weakSide, RookValueMg, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Value result = KnightValueEg + SilverValueEg + FersValueEg - RookValueEg + PushClose[distance(winnerKSq, loserKSq)] + PushToOpposingSideEdges[map_to_standard_board(pos, relative_square(strongSide, loserKSq, pos.max_rank()))]; return strongSide == pos.side_to_move() ? result : -result; } /// Mate with KSF vs K. template<> Value Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, SilverValueMg + FersValueMg, 0)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); Square winnerKSq = pos.square(strongSide); Square loserKSq = pos.square(weakSide); Value result = VALUE_KNOWN_WIN + PushClose[distance(winnerKSq, loserKSq)] + PushToOpposingSideEdges[map_to_standard_board(pos, relative_square(strongSide, loserKSq, pos.max_rank()))]; return strongSide == pos.side_to_move() ? result : -result; } /// KB and one or more pawns vs K. It checks for draws with rook pawns and /// a bishop of the wrong color. If such a draw is detected, SCALE_FACTOR_DRAW /// is returned. If not, the return value is SCALE_FACTOR_NONE, i.e. no scaling /// will be used. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(pos.non_pawn_material(strongSide) == BishopValueMg); assert(pos.count(strongSide) >= 1); // No assertions about the material of weakSide, because we want draws to // be detected even when the weaker side has some pawns. Bitboard pawns = pos.pieces(strongSide, PAWN); File pawnsFile = file_of(lsb(pawns)); // All pawns are on a single rook file? if ( (pawnsFile == FILE_A || pawnsFile == FILE_H) && !(pawns & ~file_bb(pawnsFile))) { Square bishopSq = pos.square(strongSide); Square queeningSq = relative_square(strongSide, make_square(pawnsFile, RANK_8)); Square kingSq = pos.square(weakSide); if ( opposite_colors(queeningSq, bishopSq) && distance(queeningSq, kingSq) <= 1) return SCALE_FACTOR_DRAW; } // If all the pawns are on the same B or G file, then it's potentially a draw if ( (pawnsFile == FILE_B || pawnsFile == FILE_G) && !(pos.pieces(PAWN) & ~file_bb(pawnsFile)) && pos.non_pawn_material(weakSide) == 0 && pos.count(weakSide) >= 1) { // Get weakSide pawn that is closest to the home rank Square weakPawnSq = frontmost_sq(strongSide, pos.pieces(weakSide, PAWN)); Square strongKingSq = pos.square(strongSide); Square weakKingSq = pos.square(weakSide); Square bishopSq = pos.square(strongSide); // There's potential for a draw if our pawn is blocked on the 7th rank, // the bishop cannot attack it or they only have one pawn left if ( relative_rank(strongSide, weakPawnSq) == RANK_7 && (pos.pieces(strongSide, PAWN) & (weakPawnSq + pawn_push(weakSide))) && (opposite_colors(bishopSq, weakPawnSq) || pos.count(strongSide) == 1)) { int strongKingDist = distance(weakPawnSq, strongKingSq); int weakKingDist = distance(weakPawnSq, weakKingSq); // It's a draw if the weak king is on its back two ranks, within 2 // squares of the blocking pawn and the strong king is not // closer. (I think this rule only fails in practically // unreachable positions such as 5k1K/6p1/6P1/8/8/3B4/8/8 w // and positions where qsearch will immediately correct the // problem such as 8/4k1p1/6P1/1K6/3B4/8/8/8 w) if ( relative_rank(strongSide, weakKingSq) >= RANK_7 && weakKingDist <= 2 && weakKingDist <= strongKingDist) return SCALE_FACTOR_DRAW; } } return SCALE_FACTOR_NONE; } /// KQ vs KR and one or more pawns. It tests for fortress draws with a rook on /// the third rank defended by a pawn. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, QueenValueMg, 0)); assert(pos.count(weakSide) == 1); assert(pos.count(weakSide) >= 1); Square kingSq = pos.square(weakSide); Square rsq = pos.square(weakSide); if ( relative_rank(weakSide, kingSq) <= RANK_2 && relative_rank(weakSide, pos.square(strongSide)) >= RANK_4 && relative_rank(weakSide, rsq) == RANK_3 && ( pos.pieces(weakSide, PAWN) & pos.attacks_from(kingSq, weakSide) & pos.attacks_from(rsq, strongSide))) return SCALE_FACTOR_DRAW; return SCALE_FACTOR_NONE; } /// KRP vs KR. This function knows a handful of the most important classes of /// drawn positions, but is far from perfect. It would probably be a good idea /// to add more knowledge in the future. /// /// It would also be nice to rewrite the actual code for this function, /// which is mostly copied from Glaurung 1.x, and isn't very pretty. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 1)); assert(verify_material(pos, weakSide, RookValueMg, 0)); // Assume strongSide is white and the pawn is on files A-D Square wksq = normalize(pos, strongSide, pos.square(strongSide)); Square bksq = normalize(pos, strongSide, pos.square(weakSide)); Square wrsq = normalize(pos, strongSide, pos.square(strongSide)); Square wpsq = normalize(pos, strongSide, pos.square(strongSide)); Square brsq = normalize(pos, strongSide, pos.square(weakSide)); File f = file_of(wpsq); Rank r = rank_of(wpsq); Square queeningSq = make_square(f, RANK_8); int tempo = (pos.side_to_move() == strongSide); // If the pawn is not too far advanced and the defending king defends the // queening square, use the third-rank defence. if ( r <= RANK_5 && distance(bksq, queeningSq) <= 1 && wksq <= SQ_H5 && (rank_of(brsq) == RANK_6 || (r <= RANK_3 && rank_of(wrsq) != RANK_6))) return SCALE_FACTOR_DRAW; // The defending side saves a draw by checking from behind in case the pawn // has advanced to the 6th rank with the king behind. if ( r == RANK_6 && distance(bksq, queeningSq) <= 1 && rank_of(wksq) + tempo <= RANK_6 && (rank_of(brsq) == RANK_1 || (!tempo && distance(brsq, wpsq) >= 3))) return SCALE_FACTOR_DRAW; if ( r >= RANK_6 && bksq == queeningSq && rank_of(brsq) == RANK_1 && (!tempo || distance(wksq, wpsq) >= 2)) return SCALE_FACTOR_DRAW; // White pawn on a7 and rook on a8 is a draw if black's king is on g7 or h7 // and the black rook is behind the pawn. if ( wpsq == SQ_A7 && wrsq == SQ_A8 && (bksq == SQ_H7 || bksq == SQ_G7) && file_of(brsq) == FILE_A && (rank_of(brsq) <= RANK_3 || file_of(wksq) >= FILE_D || rank_of(wksq) <= RANK_5)) return SCALE_FACTOR_DRAW; // If the defending king blocks the pawn and the attacking king is too far // away, it's a draw. if ( r <= RANK_5 && bksq == wpsq + NORTH && distance(wksq, wpsq) - tempo >= 2 && distance(wksq, brsq) - tempo >= 2) return SCALE_FACTOR_DRAW; // Pawn on the 7th rank supported by the rook from behind usually wins if the // attacking king is closer to the queening square than the defending king, // and the defending king cannot gain tempi by threatening the attacking rook. if ( r == RANK_7 && f != FILE_A && file_of(wrsq) == f && wrsq != queeningSq && (distance(wksq, queeningSq) < distance(bksq, queeningSq) - 2 + tempo) && (distance(wksq, queeningSq) < distance(bksq, wrsq) + tempo)) return ScaleFactor(SCALE_FACTOR_MAX - 2 * distance(wksq, queeningSq)); // Similar to the above, but with the pawn further back if ( f != FILE_A && file_of(wrsq) == f && wrsq < wpsq && (distance(wksq, queeningSq) < distance(bksq, queeningSq) - 2 + tempo) && (distance(wksq, wpsq + NORTH) < distance(bksq, wpsq + NORTH) - 2 + tempo) && ( distance(bksq, wrsq) + tempo >= 3 || ( distance(wksq, queeningSq) < distance(bksq, wrsq) + tempo && (distance(wksq, wpsq + NORTH) < distance(bksq, wrsq) + tempo)))) return ScaleFactor( SCALE_FACTOR_MAX - 8 * distance(wpsq, queeningSq) - 2 * distance(wksq, queeningSq)); // If the pawn is not far advanced and the defending king is somewhere in // the pawn's path, it's probably a draw. if (r <= RANK_4 && bksq > wpsq) { if (file_of(bksq) == file_of(wpsq)) return ScaleFactor(10); if ( distance(bksq, wpsq) == 1 && distance(wksq, bksq) > 2) return ScaleFactor(24 - 2 * distance(wksq, bksq)); } return SCALE_FACTOR_NONE; } template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 1)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); // Test for a rook pawn if (pos.pieces(PAWN) & (FileABB | FileHBB)) { Square ksq = pos.square(weakSide); Square bsq = pos.square(weakSide); Square psq = pos.square(strongSide); Rank rk = relative_rank(strongSide, psq); Direction push = pawn_push(strongSide); // If the pawn is on the 5th rank and the pawn (currently) is on // the same color square as the bishop then there is a chance of // a fortress. Depending on the king position give a moderate // reduction or a stronger one if the defending king is near the // corner but not trapped there. if (rk == RANK_5 && !opposite_colors(bsq, psq)) { int d = distance(psq + 3 * push, ksq); if (d <= 2 && !(d == 0 && ksq == pos.square(strongSide) + 2 * push)) return ScaleFactor(24); else return ScaleFactor(48); } // When the pawn has moved to the 6th rank we can be fairly sure // it's drawn if the bishop attacks the square in front of the // pawn from a reasonable distance and the defending king is near // the corner if ( rk == RANK_6 && distance(psq + 2 * push, ksq) <= 1 && (PseudoAttacks[strongSide][BISHOP][bsq] & (psq + push)) && distance(bsq, psq) >= 2) return ScaleFactor(8); } return SCALE_FACTOR_NONE; } /// KRPP vs KRP. There is just a single rule: if the stronger side has no passed /// pawns and the defending king is actively placed, the position is drawish. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, RookValueMg, 2)); assert(verify_material(pos, weakSide, RookValueMg, 1)); Square wpsq1 = pos.squares(strongSide)[0]; Square wpsq2 = pos.squares(strongSide)[1]; Square bksq = pos.square(weakSide); // Does the stronger side have a passed pawn? if (pos.pawn_passed(strongSide, wpsq1) || pos.pawn_passed(strongSide, wpsq2)) return SCALE_FACTOR_NONE; Rank r = std::max(relative_rank(strongSide, wpsq1), relative_rank(strongSide, wpsq2)); if ( distance(bksq, wpsq1) <= 1 && distance(bksq, wpsq2) <= 1 && relative_rank(strongSide, bksq) > r) { assert(r > RANK_1 && r < RANK_7); return ScaleFactor(KRPPKRPScaleFactors[r]); } return SCALE_FACTOR_NONE; } /// K and two or more pawns vs K. There is just a single rule here: If all pawns /// are on the same rook file and are blocked by the defending king, it's a draw. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(pos.non_pawn_material(strongSide) == VALUE_ZERO); assert(pos.count(strongSide) >= 2); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); Square ksq = pos.square(weakSide); Bitboard pawns = pos.pieces(strongSide, PAWN); // If all pawns are ahead of the king, on a single rook file and // the king is within one file of the pawns, it's a draw. if ( !(pawns & ~forward_ranks_bb(weakSide, ksq)) && !((pawns & ~FileABB) && (pawns & ~FileHBB)) && distance(ksq, lsb(pawns)) <= 1) return SCALE_FACTOR_DRAW; return SCALE_FACTOR_NONE; } /// KBP vs KB. There are two rules: if the defending king is somewhere along the /// path of the pawn, and the square of the king is not of the same color as the /// stronger side's bishop, it's a draw. If the two bishops have opposite color, /// it's almost always a draw. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, BishopValueMg, 1)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); Square pawnSq = pos.square(strongSide); Square strongBishopSq = pos.square(strongSide); Square weakBishopSq = pos.square(weakSide); Square weakKingSq = pos.square(weakSide); // Case 1: Defending king blocks the pawn, and cannot be driven away if ( file_of(weakKingSq) == file_of(pawnSq) && relative_rank(strongSide, pawnSq) < relative_rank(strongSide, weakKingSq) && ( opposite_colors(weakKingSq, strongBishopSq) || relative_rank(strongSide, weakKingSq) <= RANK_6)) return SCALE_FACTOR_DRAW; // Case 2: Opposite colored bishops if (opposite_colors(strongBishopSq, weakBishopSq)) return SCALE_FACTOR_DRAW; return SCALE_FACTOR_NONE; } /// KBPP vs KB. It detects a few basic draws with opposite-colored bishops template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, BishopValueMg, 2)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); Square wbsq = pos.square(strongSide); Square bbsq = pos.square(weakSide); if (!opposite_colors(wbsq, bbsq)) return SCALE_FACTOR_NONE; Square ksq = pos.square(weakSide); Square psq1 = pos.squares(strongSide)[0]; Square psq2 = pos.squares(strongSide)[1]; Square blockSq1, blockSq2; if (relative_rank(strongSide, psq1) > relative_rank(strongSide, psq2)) { blockSq1 = psq1 + pawn_push(strongSide); blockSq2 = make_square(file_of(psq2), rank_of(psq1)); } else { blockSq1 = psq2 + pawn_push(strongSide); blockSq2 = make_square(file_of(psq1), rank_of(psq2)); } switch (distance(psq1, psq2)) { case 0: // Both pawns are on the same file. It's an easy draw if the defender firmly // controls some square in the frontmost pawn's path. if ( file_of(ksq) == file_of(blockSq1) && relative_rank(strongSide, ksq) >= relative_rank(strongSide, blockSq1) && opposite_colors(ksq, wbsq)) return SCALE_FACTOR_DRAW; else return SCALE_FACTOR_NONE; case 1: // Pawns on adjacent files. It's a draw if the defender firmly controls the // square in front of the frontmost pawn's path, and the square diagonally // behind this square on the file of the other pawn. if ( ksq == blockSq1 && opposite_colors(ksq, wbsq) && ( bbsq == blockSq2 || (pos.attacks_from(blockSq2, weakSide) & pos.pieces(weakSide, BISHOP)) || distance(psq1, psq2) >= 2)) return SCALE_FACTOR_DRAW; else if ( ksq == blockSq2 && opposite_colors(ksq, wbsq) && ( bbsq == blockSq1 || (pos.attacks_from(blockSq1, weakSide) & pos.pieces(weakSide, BISHOP)))) return SCALE_FACTOR_DRAW; else return SCALE_FACTOR_NONE; default: // The pawns are not on the same file or adjacent files. No scaling. return SCALE_FACTOR_NONE; } } /// KBP vs KN. There is a single rule: If the defending king is somewhere along /// the path of the pawn, and the square of the king is not of the same color as /// the stronger side's bishop, it's a draw. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, BishopValueMg, 1)); assert(verify_material(pos, weakSide, KnightValueMg, 0)); Square pawnSq = pos.square(strongSide); Square strongBishopSq = pos.square(strongSide); Square weakKingSq = pos.square(weakSide); if ( file_of(weakKingSq) == file_of(pawnSq) && relative_rank(strongSide, pawnSq) < relative_rank(strongSide, weakKingSq) && ( opposite_colors(weakKingSq, strongBishopSq) || relative_rank(strongSide, weakKingSq) <= RANK_6)) return SCALE_FACTOR_DRAW; return SCALE_FACTOR_NONE; } /// KNP vs K. There is a single rule: if the pawn is a rook pawn on the 7th rank /// and the defending king prevents the pawn from advancing, the position is drawn. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg, 1)); assert(verify_material(pos, weakSide, VALUE_ZERO, 0)); // Assume strongSide is white and the pawn is on files A-D Square pawnSq = normalize(pos, strongSide, pos.square(strongSide)); Square weakKingSq = normalize(pos, strongSide, pos.square(weakSide)); if (pawnSq == SQ_A7 && distance(SQ_A8, weakKingSq) <= 1) return SCALE_FACTOR_DRAW; return SCALE_FACTOR_NONE; } /// KNP vs KB. If knight can block bishop from taking pawn, it's a win. /// Otherwise the position is drawn. template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, KnightValueMg, 1)); assert(verify_material(pos, weakSide, BishopValueMg, 0)); Square pawnSq = pos.square(strongSide); Square bishopSq = pos.square(weakSide); Square weakKingSq = pos.square(weakSide); // King needs to get close to promoting pawn to prevent knight from blocking. // Rules for this are very tricky, so just approximate. if (forward_file_bb(strongSide, pawnSq) & pos.attacks_from(bishopSq, weakSide)) return ScaleFactor(distance(weakKingSq, pawnSq)); return SCALE_FACTOR_NONE; } /// KP vs KP. This is done by removing the weakest side's pawn and probing the /// KP vs K bitbase: If the weakest side has a draw without the pawn, it probably /// has at least a draw with the pawn as well. The exception is when the stronger /// side's pawn is far advanced and not on a rook file; in this case it is often /// possible to win (e.g. 8/4k3/3p4/3P4/6K1/8/8/8 w - - 0 1). template<> ScaleFactor Endgame::operator()(const Position& pos) const { assert(verify_material(pos, strongSide, VALUE_ZERO, 1)); assert(verify_material(pos, weakSide, VALUE_ZERO, 1)); // Assume strongSide is white and the pawn is on files A-D Square wksq = normalize(pos, strongSide, pos.square(strongSide)); Square bksq = normalize(pos, strongSide, pos.square(weakSide)); Square psq = normalize(pos, strongSide, pos.square(strongSide)); Color us = strongSide == pos.side_to_move() ? WHITE : BLACK; // If the pawn has advanced to the fifth rank or further, and is not a // rook pawn, it's too dangerous to assume that it's at least a draw. if (rank_of(psq) >= RANK_5 && file_of(psq) != FILE_A) return SCALE_FACTOR_NONE; // Probe the KPK bitbase with the weakest side's pawn removed. If it's a draw, // it's probably at least a draw even with the pawn. if ( pos.promotion_rank() == RANK_8 && RANK_MAX == RANK_8 && pos.promotion_piece_types().find(QUEEN) != pos.promotion_piece_types().end()) return Bitbases::probe(wksq, psq, bksq, us) ? SCALE_FACTOR_NONE : SCALE_FACTOR_DRAW; else return SCALE_FACTOR_NONE; } Fairy-Stockfish-fairy_sf_11_1/src/endgame.h000066400000000000000000000072361366242550200207610ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef ENDGAME_H_INCLUDED #define ENDGAME_H_INCLUDED #include #include #include #include #include #include "position.h" #include "types.h" /// EndgameCode lists all supported endgame functions by corresponding codes enum EndgameCode { EVALUATION_FUNCTIONS, KNNK, // KNN vs K KNNKP, // KNN vs KP KXK, // Generic "mate lone king" eval KBNK, // KBN vs K KPK, // KP vs K KRKP, // KR vs KP KRKB, // KR vs KB KRKN, // KR vs KN KQKP, // KQ vs KP KQKR, // KQ vs KR // Fairy piece endgames KFsPsK, // KFsPsK vs K KNSK, // KNS vs K KNFK, // KNF vs K KNSFKR, // KNSFKR vs K KSFK, // KSF vs K SCALING_FUNCTIONS, KBPsK, // KB and pawns vs K KQKRPs, // KQ vs KR and pawns KRPKR, // KRP vs KR KRPKB, // KRP vs KB KRPPKRP, // KRPP vs KRP KPsK, // K and pawns vs K KBPKB, // KBP vs KB KBPPKB, // KBPP vs KB KBPKN, // KBP vs KN KNPK, // KNP vs K KNPKB, // KNP vs KB KPKP // KP vs KP }; /// Endgame functions can be of two types depending on whether they return a /// Value or a ScaleFactor. template using eg_type = typename std::conditional<(E < SCALING_FUNCTIONS), Value, ScaleFactor>::type; /// Base and derived functors for endgame evaluation and scaling functions template struct EndgameBase { explicit EndgameBase(Color c) : strongSide(c), weakSide(~c) {} virtual ~EndgameBase() = default; virtual T operator()(const Position&) const = 0; const Color strongSide, weakSide; }; template> struct Endgame : public EndgameBase { explicit Endgame(Color c) : EndgameBase(c) {} T operator()(const Position&) const override; }; /// The Endgames namespace handles the pointers to endgame evaluation and scaling /// base objects in two std::map. We use polymorphism to invoke the actual /// endgame function by calling its virtual operator(). namespace Endgames { template using Ptr = std::unique_ptr>; template using Map = std::unordered_map>; extern std::pair, Map> maps; void init(); template Map& map() { return std::get::value>(maps); } template> void add(const std::string& code) { StateInfo st; map()[Position().set(code, WHITE, &st).material_key()] = Ptr(new Endgame(WHITE)); map()[Position().set(code, BLACK, &st).material_key()] = Ptr(new Endgame(BLACK)); } template const EndgameBase* probe(Key key) { auto it = map().find(key); return it != map().end() ? it->second.get() : nullptr; } } #endif // #ifndef ENDGAME_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/evaluate.cpp000066400000000000000000001367211366242550200215240ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include // For std::memset #include #include #include "bitboard.h" #include "evaluate.h" #include "material.h" #include "pawns.h" #include "thread.h" #include "uci.h" namespace Trace { enum Tracing { NO_TRACE, TRACE }; enum Term { // The first PIECE_TYPE_NB entries are reserved for PieceType MATERIAL = PIECE_TYPE_NB, IMBALANCE, MOBILITY, THREAT, PASSED, SPACE, INITIATIVE, VARIANT, TOTAL, TERM_NB }; Score scores[TERM_NB][COLOR_NB]; double to_cp(Value v) { return double(v) / PawnValueEg; } void add(int idx, Color c, Score s) { scores[idx][c] = s; } void add(int idx, Score w, Score b = SCORE_ZERO) { scores[idx][WHITE] = w; scores[idx][BLACK] = b; } std::ostream& operator<<(std::ostream& os, Score s) { os << std::setw(5) << to_cp(mg_value(s)) << " " << std::setw(5) << to_cp(eg_value(s)); return os; } std::ostream& operator<<(std::ostream& os, Term t) { if (t == MATERIAL || t == IMBALANCE || t == INITIATIVE || t == TOTAL) os << " ---- ----" << " | " << " ---- ----"; else os << scores[t][WHITE] << " | " << scores[t][BLACK]; os << " | " << scores[t][WHITE] - scores[t][BLACK] << "\n"; return os; } } using namespace Trace; namespace { // Threshold for lazy and space evaluation constexpr Value LazyThreshold = Value(1400); constexpr Value SpaceThreshold = Value(12222); // KingAttackWeights[PieceType] contains king attack weights by piece type constexpr int KingAttackWeights[PIECE_TYPE_NB] = { 0, 0, 81, 52, 44, 10, 40 }; // Penalties for enemy's safe checks constexpr int QueenSafeCheck = 780; constexpr int RookSafeCheck = 1080; constexpr int BishopSafeCheck = 635; constexpr int KnightSafeCheck = 790; constexpr int OtherSafeCheck = 600; #define S(mg, eg) make_score(mg, eg) // MobilityBonus[PieceType-2][attacked] contains bonuses for middle and end game, // indexed by piece type and number of attacked squares in the mobility area. #ifdef LARGEBOARDS constexpr Score MobilityBonus[][38] = { #else constexpr Score MobilityBonus[][32] = { #endif { S(-62,-81), S(-53,-56), S(-12,-30), S( -4,-14), S( 3, 8), S( 13, 15), // Knights S( 22, 23), S( 28, 27), S( 33, 33) }, { S(-48,-59), S(-20,-23), S( 16, -3), S( 26, 13), S( 38, 24), S( 51, 42), // Bishops S( 55, 54), S( 63, 57), S( 63, 65), S( 68, 73), S( 81, 78), S( 81, 86), S( 91, 88), S( 98, 97) }, { S(-58,-76), S(-27,-18), S(-15, 28), S(-10, 55), S( -5, 69), S( -2, 82), // Rooks S( 9,112), S( 16,118), S( 30,132), S( 29,142), S( 32,155), S( 38,165), S( 46,166), S( 48,169), S( 58,171) }, { S(-39,-36), S(-21,-15), S( 3, 8), S( 3, 18), S( 14, 34), S( 22, 54), // Queens S( 28, 61), S( 41, 73), S( 43, 79), S( 48, 92), S( 56, 94), S( 60,104), S( 60,113), S( 66,120), S( 67,123), S( 70,126), S( 71,133), S( 73,136), S( 79,140), S( 88,143), S( 88,148), S( 99,166), S(102,170), S(102,175), S(106,184), S(109,191), S(113,206), S(116,212) } }; constexpr Score MaxMobility = S(250, 250); constexpr Score DropMobility = S(10, 10); // RookOnFile[semiopen/open] contains bonuses for each rook when there is // no (friendly) pawn on the rook file. constexpr Score RookOnFile[] = { S(21, 4), S(47, 25) }; // ThreatByMinor/ByRook[attacked PieceType] contains bonuses according to // which piece type attacks which one. Attacks on lesser pieces which are // pawn-defended are not considered. constexpr Score ThreatByMinor[PIECE_TYPE_NB] = { S(0, 0), S(6, 32), S(59, 41), S(79, 56), S(90, 119), S(79, 161) }; constexpr Score ThreatByRook[PIECE_TYPE_NB] = { S(0, 0), S(3, 44), S(38, 71), S(38, 61), S(0, 38), S(51, 38) }; // PassedRank[Rank] contains a bonus according to the rank of a passed pawn constexpr Score PassedRank[RANK_NB] = { S(0, 0), S(10, 28), S(17, 33), S(15, 41), S(62, 72), S(168, 177), S(276, 260) }; // KingProximity contains a penalty according to distance from king constexpr Score KingProximity = S(1, 3); // Assorted bonuses and penalties constexpr Score BishopPawns = S( 3, 7); constexpr Score CorneredBishop = S( 50, 50); constexpr Score FlankAttacks = S( 8, 0); constexpr Score Hanging = S( 69, 36); constexpr Score KingProtector = S( 7, 8); constexpr Score KnightOnQueen = S( 16, 12); constexpr Score LongDiagonalBishop = S( 45, 0); constexpr Score MinorBehindPawn = S( 18, 3); constexpr Score Outpost = S( 30, 21); constexpr Score PassedFile = S( 11, 8); constexpr Score PawnlessFlank = S( 17, 95); constexpr Score RestrictedPiece = S( 7, 7); constexpr Score ReachableOutpost = S( 32, 10); constexpr Score RookOnQueenFile = S( 7, 6); constexpr Score SliderOnQueen = S( 59, 18); constexpr Score ThreatByKing = S( 24, 89); constexpr Score ThreatByPawnPush = S( 48, 39); constexpr Score ThreatBySafePawn = S(173, 94); constexpr Score TrappedRook = S( 52, 10); constexpr Score WeakQueen = S( 49, 15); #undef S // Evaluation class computes and stores attacks tables and other working data template class Evaluation { public: Evaluation() = delete; explicit Evaluation(const Position& p) : pos(p) {} Evaluation& operator=(const Evaluation&) = delete; Value value(); private: template void initialize(); template Score pieces(PieceType Pt); template Score hand(PieceType pt); template Score king() const; template Score threats() const; template Score passed() const; template Score space() const; template Score variant() const; ScaleFactor scale_factor(Value eg) const; Score initiative(Score score) const; const Position& pos; Material::Entry* me; Pawns::Entry* pe; Bitboard mobilityArea[COLOR_NB]; Score mobility[COLOR_NB] = { SCORE_ZERO, SCORE_ZERO }; // attackedBy[color][piece type] is a bitboard representing all squares // attacked by a given color and piece type. Special "piece types" which // is also calculated is ALL_PIECES. Bitboard attackedBy[COLOR_NB][PIECE_TYPE_NB]; // attackedBy2[color] are the squares attacked by at least 2 units of a given // color, including x-rays. But diagonal x-rays through pawns are not computed. Bitboard attackedBy2[COLOR_NB]; // kingRing[color] are the squares adjacent to the king plus some other // very near squares, depending on king position. Bitboard kingRing[COLOR_NB]; // kingAttackersCount[color] is the number of pieces of the given color // which attack a square in the kingRing of the enemy king. int kingAttackersCount[COLOR_NB]; int kingAttackersCountInHand[COLOR_NB]; // kingAttackersWeight[color] is the sum of the "weights" of the pieces of // the given color which attack a square in the kingRing of the enemy king. // The weights of the individual piece types are given by the elements in // the KingAttackWeights array. int kingAttackersWeight[COLOR_NB]; int kingAttackersWeightInHand[COLOR_NB]; // kingAttacksCount[color] is the number of attacks by the given color to // squares directly adjacent to the enemy king. Pieces which attack more // than one square are counted multiple times. For instance, if there is // a white knight on g5 and black's king is on g8, this white knight adds 2 // to kingAttacksCount[WHITE]. int kingAttacksCount[COLOR_NB]; }; // Evaluation::initialize() computes king and pawn attacks, and the king ring // bitboard for a given color. This is done at the beginning of the evaluation. template template void Evaluation::initialize() { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Up = pawn_push(Us); constexpr Direction Down = -Up; Bitboard LowRanks = rank_bb(relative_rank(Us, RANK_2, pos.max_rank())) | rank_bb(relative_rank(Us, RANK_3, pos.max_rank())); const Square ksq = pos.count(Us) ? pos.square(Us) : SQ_NONE; Bitboard dblAttackByPawn = pawn_double_attacks_bb(pos.pieces(Us, PAWN)); // Find our pawns that are blocked or on the first two ranks Bitboard b = pos.pieces(Us, PAWN) & (shift(pos.pieces()) | LowRanks); // Squares occupied by those pawns, by our king or queen, by blockers to attacks on our king // or controlled by enemy pawns are excluded from the mobility area. if (pos.must_capture()) mobilityArea[Us] = AllSquares; else mobilityArea[Us] = ~(b | pos.pieces(Us, KING, QUEEN) | pos.blockers_for_king(Us) | pe->pawn_attacks(Them) | shift(pos.pieces(Them, SHOGI_PAWN, SOLDIER)) | shift(pos.promoted_soldiers(Them)) | shift(pos.promoted_soldiers(Them))); // Initialize attackedBy[] for king and pawns attackedBy[Us][KING] = pos.count(Us) ? pos.attacks_from(ksq, Us) : Bitboard(0); attackedBy[Us][PAWN] = pe->pawn_attacks(Us); attackedBy[Us][SHOGI_PAWN] = shift(pos.pieces(Us, SHOGI_PAWN)); attackedBy[Us][ALL_PIECES] = attackedBy[Us][KING] | attackedBy[Us][PAWN] | attackedBy[Us][SHOGI_PAWN]; attackedBy2[Us] = (attackedBy[Us][KING] & attackedBy[Us][PAWN]) | (attackedBy[Us][KING] & attackedBy[Us][SHOGI_PAWN]) | (attackedBy[Us][PAWN] & attackedBy[Us][SHOGI_PAWN]) | dblAttackByPawn; // Init our king safety tables if (!pos.count(Us)) kingRing[Us] = Bitboard(0); else { Square s = make_square(clamp(file_of(ksq), FILE_B, File(pos.max_file() - 1)), clamp(rank_of(ksq), RANK_2, Rank(pos.max_rank() - 1))); kingRing[Us] = PseudoAttacks[Us][KING][s] | s; } kingAttackersCount[Them] = popcount(kingRing[Us] & pe->pawn_attacks(Them)); kingAttacksCount[Them] = kingAttackersWeight[Them] = 0; kingAttackersCountInHand[Them] = kingAttackersWeightInHand[Them] = 0; // Remove from kingRing[] the squares defended by two pawns kingRing[Us] &= ~dblAttackByPawn; kingRing[Us] &= pos.board_bb(); } // Evaluation::pieces() scores pieces of a given color and type template template Score Evaluation::pieces(PieceType Pt) { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Down = -pawn_push(Us); constexpr Bitboard OutpostRanks = (Us == WHITE ? Rank4BB | Rank5BB | Rank6BB : Rank5BB | Rank4BB | Rank3BB); const Square* pl = pos.squares(Us, Pt); Bitboard b, bb; Score score = SCORE_ZERO; attackedBy[Us][Pt] = 0; for (Square s = *pl; s != SQ_NONE; s = *++pl) { // Find attacked squares, including x-ray attacks for bishops and rooks b = Pt == BISHOP ? attacks_bb(s, pos.pieces() ^ pos.pieces(QUEEN)) : Pt == ROOK ? attacks_bb< ROOK>(s, pos.pieces() ^ pos.pieces(QUEEN) ^ pos.pieces(Us, ROOK)) : pos.attacks_from(Us, Pt, s); // Restrict mobility to actual squares of board b &= pos.board_bb(); if (pos.blockers_for_king(Us) & s) b &= LineBB[pos.square(Us)][s]; attackedBy2[Us] |= attackedBy[Us][ALL_PIECES] & b; attackedBy[Us][Pt] |= b; attackedBy[Us][ALL_PIECES] |= b; if (b & kingRing[Them]) { kingAttackersCount[Us]++; kingAttackersWeight[Us] += KingAttackWeights[std::min(int(Pt), QUEEN + 1)]; kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]); } if (Pt > QUEEN) b = (b & pos.pieces()) | (pos.moves_from(Us, Pt, s) & ~pos.pieces() & pos.board_bb()); int mob = popcount(b & mobilityArea[Us]); if (Pt <= QUEEN) mobility[Us] += MobilityBonus[Pt - 2][mob]; else mobility[Us] += MaxMobility * (mob - 1) / (8 + mob); // Piece promotion bonus if (pos.promoted_piece_type(Pt) != NO_PIECE_TYPE) { if (promotion_zone_bb(Us, pos.promotion_rank(), pos.max_rank()) & (b | s)) score += make_score(PieceValue[MG][pos.promoted_piece_type(Pt)] - PieceValue[MG][Pt], PieceValue[EG][pos.promoted_piece_type(Pt)] - PieceValue[EG][Pt]) / 10; } else if (pos.captures_to_hand() && pos.unpromoted_piece_on(s)) score += make_score(PieceValue[MG][Pt] - PieceValue[MG][pos.unpromoted_piece_on(s)], PieceValue[EG][Pt] - PieceValue[EG][pos.unpromoted_piece_on(s)]) / 8; // Penalty if the piece is far from the kings in drop variants if ((pos.captures_to_hand() || pos.two_boards()) && pos.count(Them) && pos.count(Us)) score -= KingProximity * distance(s, pos.square(Us)) * distance(s, pos.square(Them)); if (Pt == BISHOP || Pt == KNIGHT) { // Bonus if piece is on an outpost square or can reach one bb = OutpostRanks & attackedBy[Us][PAWN] & ~pe->pawn_attacks_span(Them); if (bb & s) score += Outpost * (Pt == KNIGHT ? 2 : 1); else if (Pt == KNIGHT && bb & b & ~pos.pieces(Us)) score += ReachableOutpost; // Knight and Bishop bonus for being right behind a pawn if (shift(pos.pieces(PAWN)) & s) score += MinorBehindPawn; // Penalty if the piece is far from the king if (pos.count(Us)) score -= KingProtector * distance(s, pos.square(Us)); if (Pt == BISHOP) { // Penalty according to number of pawns on the same color square as the // bishop, bigger when the center files are blocked with pawns. Bitboard blocked = pos.pieces(Us, PAWN) & shift(pos.pieces()); score -= BishopPawns * pos.pawns_on_same_color_squares(Us, s) * (1 + popcount(blocked & CenterFiles)); // Bonus for bishop on a long diagonal which can "see" both center squares if (more_than_one(attacks_bb(s, pos.pieces(PAWN)) & Center)) score += LongDiagonalBishop; // An important Chess960 pattern: a cornered bishop blocked by a friendly // pawn diagonally in front of it is a very serious problem, especially // when that pawn is also blocked. if ( pos.is_chess960() && (s == relative_square(Us, SQ_A1) || s == relative_square(Us, SQ_H1))) { Direction d = pawn_push(Us) + (file_of(s) == FILE_A ? EAST : WEST); if (pos.piece_on(s + d) == make_piece(Us, PAWN)) score -= !pos.empty(s + d + pawn_push(Us)) ? CorneredBishop * 4 : pos.piece_on(s + d + d) == make_piece(Us, PAWN) ? CorneredBishop * 2 : CorneredBishop; } } } if (Pt == ROOK) { // Bonus for rook on the same file as a queen if (file_bb(s) & pos.pieces(QUEEN)) score += RookOnQueenFile; // Bonus for rook on an open or semi-open file if (pos.is_on_semiopen_file(Us, s)) score += RookOnFile[pos.is_on_semiopen_file(Them, s)]; // Penalty when trapped by the king, even more if the king cannot castle else if (mob <= 3 && pos.count(Us)) { File kf = file_of(pos.square(Us)); if ((kf < FILE_E) == (file_of(s) < kf)) score -= TrappedRook * (1 + !pos.castling_rights(Us)); } } if (Pt == QUEEN) { // Penalty if any relative pin or discovered attack against the queen Bitboard queenPinners; if (pos.slider_blockers(pos.pieces(Them, ROOK, BISHOP), s, queenPinners, Them)) score -= WeakQueen; } } if (T) Trace::add(Pt, Us, score); return score; } // Evaluation::hand() scores pieces of a given color and type in hand template template Score Evaluation::hand(PieceType pt) { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); Score score = SCORE_ZERO; if (pos.count_in_hand(Us, pt)) { Bitboard b = pos.drop_region(Us, pt) & ~pos.pieces() & (~attackedBy2[Them] | attackedBy[Us][ALL_PIECES]); if ((b & kingRing[Them]) && pt != SHOGI_PAWN) { kingAttackersCountInHand[Us] += pos.count_in_hand(Us, pt); kingAttackersWeightInHand[Us] += KingAttackWeights[std::min(int(pt), QUEEN + 1)] * pos.count_in_hand(Us, pt); kingAttacksCount[Us] += popcount(b & attackedBy[Them][KING]); } Bitboard theirHalf = pos.board_bb() & ~forward_ranks_bb(Them, relative_rank(Them, Rank((pos.max_rank() - 1) / 2), pos.max_rank())); mobility[Us] += DropMobility * popcount(b & theirHalf & ~attackedBy[Them][ALL_PIECES]); } return score; } // Evaluation::king() assigns bonuses and penalties to a king of a given color template template Score Evaluation::king() const { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); Rank r = relative_rank(Us, std::min(Rank((pos.max_rank() - 1) / 2 + 1), pos.max_rank()), pos.max_rank()); Bitboard Camp = pos.board_bb() & ~forward_ranks_bb(Us, r); if (!pos.count(Us) || !pos.checking_permitted()) return SCORE_ZERO; Bitboard weak, b1, b2, b3, safe, unsafeChecks = 0; Bitboard queenChecks, knightChecks, pawnChecks, otherChecks; int kingDanger = 0; const Square ksq = pos.square(Us); // Init the score with king shelter and enemy pawns storm Score score = pe->king_safety(pos); // Attacked squares defended at most once by our queen or king weak = attackedBy[Them][ALL_PIECES] & ~attackedBy2[Us] & (~attackedBy[Us][ALL_PIECES] | attackedBy[Us][KING] | attackedBy[Us][QUEEN]); // Analyse the safe enemy's checks which are possible on next move safe = ~pos.pieces(Them); if (!pos.check_counting() || pos.checks_remaining(Them) > 1) safe &= ~attackedBy[Us][ALL_PIECES] | (weak & attackedBy2[Them]); b1 = attacks_bb(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN)); b2 = attacks_bb(ksq, pos.pieces() ^ pos.pieces(Us, QUEEN)); std::function get_attacks = [this](Color c, PieceType pt) { return attackedBy[c][pt] | (pos.piece_drops() && pos.count_in_hand(c, pt) ? pos.drop_region(c, pt) & ~pos.pieces() : Bitboard(0)); }; for (PieceType pt : pos.piece_types()) { switch (pt) { case QUEEN: // Enemy queen safe checks: we count them only if they are from squares from // which we can't give a rook check, because rook checks are more valuable. queenChecks = (b1 | b2) & get_attacks(Them, QUEEN) & pos.board_bb() & safe & ~attackedBy[Us][QUEEN] & ~(b1 & attackedBy[Them][ROOK]); if (queenChecks) kingDanger += QueenSafeCheck; break; case ROOK: case BISHOP: case KNIGHT: knightChecks = attacks_bb(Us, pt, ksq, pos.pieces() ^ pos.pieces(Us, QUEEN)) & get_attacks(Them, pt) & pos.board_bb(); if (knightChecks & safe) kingDanger += pt == ROOK ? RookSafeCheck : pt == BISHOP ? BishopSafeCheck : KnightSafeCheck; else unsafeChecks |= knightChecks; break; case PAWN: if (pos.piece_drops() && pos.count_in_hand(Them, pt)) { pawnChecks = attacks_bb(Us, pt, ksq, pos.pieces()) & ~pos.pieces() & pos.board_bb(); if (pawnChecks & safe) kingDanger += OtherSafeCheck; else unsafeChecks |= pawnChecks; } break; case SHOGI_PAWN: case KING: break; default: otherChecks = attacks_bb(Us, pt, ksq, pos.pieces()) & get_attacks(Them, pt) & pos.board_bb(); if (otherChecks & safe) kingDanger += OtherSafeCheck; else unsafeChecks |= otherChecks; } } // Virtual piece drops if (pos.two_boards() && pos.piece_drops()) { for (PieceType pt : pos.piece_types()) if (!pos.count_in_hand(Them, pt) && (attacks_bb(Us, pt, ksq, pos.pieces()) & safe & pos.drop_region(Them, pt) & ~pos.pieces())) { kingDanger += OtherSafeCheck * 500 / (500 + PieceValue[MG][pt]); // Presumably a mate threat if (!(attackedBy[Us][KING] & ~(attackedBy[Them][ALL_PIECES] | pos.pieces(Us)))) kingDanger += 2000; } } if (pos.check_counting()) kingDanger += kingDanger * 7 / (3 + pos.checks_remaining(Them)); Square s = file_of(ksq) == FILE_A ? ksq + EAST : file_of(ksq) == pos.max_file() ? ksq + WEST : ksq; Bitboard kingFlank = pos.max_file() == FILE_H ? KingFlank[file_of(ksq)] : file_bb(s) | adjacent_files_bb(s); // Find the squares that opponent attacks in our king flank, the squares // which they attack twice in that flank, and the squares that we defend. b1 = attackedBy[Them][ALL_PIECES] & kingFlank & Camp; b2 = b1 & attackedBy2[Them]; b3 = attackedBy[Us][ALL_PIECES] & kingFlank & Camp; int kingFlankAttack = popcount(b1) + popcount(b2); int kingFlankDefense = popcount(b3); kingDanger += kingAttackersCount[Them] * kingAttackersWeight[Them] + kingAttackersCountInHand[Them] * kingAttackersWeight[Them] + kingAttackersCount[Them] * kingAttackersWeightInHand[Them] + 185 * popcount(kingRing[Us] & (weak | ~pos.board_bb(Us, KING))) * (1 + pos.captures_to_hand() + pos.check_counting()) + 148 * popcount(unsafeChecks) * (1 + pos.check_counting()) + 98 * popcount(pos.blockers_for_king(Us)) + 69 * kingAttacksCount[Them] * (2 + 8 * pos.check_counting() + pos.captures_to_hand()) / 2 + 3 * kingFlankAttack * kingFlankAttack / 8 + mg_value(mobility[Them] - mobility[Us]) - 873 * !(pos.major_pieces(Them) || pos.captures_to_hand()) * 2 / (2 + 2 * pos.check_counting() + 2 * pos.two_boards() + 2 * pos.makpong() + (pos.king_type() != KING) * (pos.diagonal_lines() ? 1 : 2)) - 100 * bool(attackedBy[Us][KNIGHT] & attackedBy[Us][KING]) - 6 * mg_value(score) / 8 - 4 * kingFlankDefense + 37; // Transform the kingDanger units into a Score, and subtract it from the evaluation if (kingDanger > 100) score -= make_score(std::min(kingDanger * kingDanger / 4096, 3000), kingDanger / 16); // Penalty when our king is on a pawnless flank if (!(pos.pieces(PAWN) & kingFlank)) score -= PawnlessFlank; // Penalty if king flank is under attack, potentially moving toward the king score -= FlankAttacks * kingFlankAttack * (1 + 5 * pos.captures_to_hand() + pos.check_counting()); if (pos.check_counting()) score += make_score(0, mg_value(score) * 2 / (2 + pos.checks_remaining(Them))); if (pos.king_type() == WAZIR) score += make_score(0, mg_value(score) / 2); // For drop games, king danger is independent of game phase if (pos.captures_to_hand() || pos.two_boards()) score = make_score(mg_value(score), mg_value(score)) * 2 / (2 + 16 / pos.max_rank() * !pos.shogi_doubled_pawn()); if (T) Trace::add(KING, Us, score); return score; } // Evaluation::threats() assigns bonuses according to the types of the // attacking and the attacked pieces. template template Score Evaluation::threats() const { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Up = pawn_push(Us); constexpr Bitboard TRank3BB = (Us == WHITE ? Rank3BB : Rank6BB); Bitboard b, weak, defended, nonPawnEnemies, stronglyProtected, safe; Score score = SCORE_ZERO; // Bonuses for variants with mandatory captures if (pos.must_capture()) { // Penalties for possible captures score -= make_score(100, 100) * popcount(attackedBy[Us][ALL_PIECES] & pos.pieces(Them)); // Bonus if we threaten to force captures Bitboard moves = 0, piecebb = pos.pieces(Us); while (piecebb) { Square s = pop_lsb(&piecebb); if (type_of(pos.piece_on(s)) != KING) moves |= pos.moves_from(Us, type_of(pos.piece_on(s)), s); } score += make_score(200, 200) * popcount(attackedBy[Them][ALL_PIECES] & moves & ~pos.pieces()); score += make_score(200, 220) * popcount(attackedBy[Them][ALL_PIECES] & moves & ~pos.pieces() & ~attackedBy2[Us]); } // Extinction threats if (pos.extinction_value() == -VALUE_MATE) { Bitboard bExt = attackedBy[Us][ALL_PIECES] & pos.pieces(Them); while (bExt) { PieceType pt = type_of(pos.piece_on(pop_lsb(&bExt))); int denom = std::max(pos.count_with_hand(Them, pt) - pos.extinction_piece_count(), 1); if (pos.extinction_piece_types().find(pt) != pos.extinction_piece_types().end()) score += make_score(1000, 1000) / (denom * denom); } } // Non-pawn enemies nonPawnEnemies = pos.pieces(Them) & ~pos.pieces(PAWN, SHOGI_PAWN) & ~pos.pieces(SOLDIER); // Squares strongly protected by the enemy, either because they defend the // square with a pawn, or because they defend the square twice and we don't. stronglyProtected = (attackedBy[Them][PAWN] | attackedBy[Them][SHOGI_PAWN] | attackedBy[Them][SOLDIER]) | (attackedBy2[Them] & ~attackedBy2[Us]); // Non-pawn enemies, strongly protected defended = nonPawnEnemies & stronglyProtected; // Enemies not strongly protected and under our attack weak = pos.pieces(Them) & ~stronglyProtected & attackedBy[Us][ALL_PIECES]; // Bonus according to the kind of attacking pieces if (defended | weak) { b = (defended | weak) & (attackedBy[Us][KNIGHT] | attackedBy[Us][BISHOP]); while (b) score += ThreatByMinor[type_of(pos.piece_on(pop_lsb(&b)))]; b = weak & attackedBy[Us][ROOK]; while (b) score += ThreatByRook[type_of(pos.piece_on(pop_lsb(&b)))]; if (weak & attackedBy[Us][KING]) score += ThreatByKing; b = ~attackedBy[Them][ALL_PIECES] | (nonPawnEnemies & attackedBy2[Us]); score += Hanging * popcount(weak & b); } // Bonus for restricting their piece moves b = attackedBy[Them][ALL_PIECES] & ~stronglyProtected & attackedBy[Us][ALL_PIECES]; score += RestrictedPiece * popcount(b); // Protected or unattacked squares safe = ~attackedBy[Them][ALL_PIECES] | attackedBy[Us][ALL_PIECES]; // Bonus for attacking enemy pieces with our relatively safe pawns b = pos.pieces(Us, PAWN) & safe; b = pawn_attacks_bb(b) & nonPawnEnemies; score += ThreatBySafePawn * popcount(b); // Find squares where our pawns can push on the next move b = shift(pos.pieces(Us, PAWN)) & ~pos.pieces(); b |= shift(b & TRank3BB) & ~pos.pieces(); // Keep only the squares which are relatively safe b &= ~attackedBy[Them][PAWN] & safe; // Bonus for safe pawn threats on the next move b = (pawn_attacks_bb(b) | shift(shift(pos.pieces(Us, SHOGI_PAWN, SOLDIER)))) & nonPawnEnemies; score += ThreatByPawnPush * popcount(b); // Bonus for threats on the next moves against enemy queen if (pos.count(Them) == 1) { Square s = pos.square(Them); safe = mobilityArea[Us] & ~stronglyProtected; b = attackedBy[Us][KNIGHT] & pos.attacks_from(s, Us); score += KnightOnQueen * popcount(b & safe); b = (attackedBy[Us][BISHOP] & pos.attacks_from(s, Us)) | (attackedBy[Us][ROOK ] & pos.attacks_from(s, Us)); score += SliderOnQueen * popcount(b & safe & attackedBy2[Us]); } if (T) Trace::add(THREAT, Us, score); return score; } // Evaluation::passed() evaluates the passed pawns and candidate passed // pawns of the given color. template template Score Evaluation::passed() const { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Up = pawn_push(Us); auto king_proximity = [&](Color c, Square s) { return pos.count(c) ? std::min(distance(pos.square(c), s), 5) : 5; }; Bitboard b, bb, squaresToQueen, unsafeSquares; Score score = SCORE_ZERO; b = pe->passed_pawns(Us); while (b) { Square s = pop_lsb(&b); assert(!(pos.pieces(Them, PAWN) & forward_file_bb(Us, s + Up))); int r = std::max(RANK_8 - std::max(pos.promotion_rank() - relative_rank(Us, s, pos.max_rank()), 0), 0); Score bonus = PassedRank[r]; if (r > RANK_3) { int w = 5 * r - 13; Square blockSq = s + Up; // Skip bonus for antichess variants if (pos.extinction_value() != VALUE_MATE) { // Adjust bonus based on the king's proximity bonus += make_score(0, ( (king_proximity(Them, blockSq) * 19) / 4 - king_proximity(Us, blockSq) * 2) * w); // If blockSq is not the queening square then consider also a second push if (r != RANK_7) bonus -= make_score(0, king_proximity(Us, blockSq + Up) * w); } // If the pawn is free to advance, then increase the bonus if (pos.empty(blockSq)) { squaresToQueen = forward_file_bb(Us, s); unsafeSquares = passed_pawn_span(Us, s); bb = forward_file_bb(Them, s) & pos.pieces(ROOK, QUEEN); if (!(pos.pieces(Them) & bb)) unsafeSquares &= attackedBy[Them][ALL_PIECES]; // If there are no enemy attacks on passed pawn span, assign a big bonus. // Otherwise assign a smaller bonus if the path to queen is not attacked // and even smaller bonus if it is attacked but block square is not. int k = !unsafeSquares ? 35 : !(unsafeSquares & squaresToQueen) ? 20 : !(unsafeSquares & blockSq) ? 9 : 0 ; // Assign a larger bonus if the block square is defended if ((pos.pieces(Us) & bb) || (attackedBy[Us][ALL_PIECES] & blockSq)) k += 5; bonus += make_score(k * w, k * w); } } // r > RANK_3 // Scale down bonus for candidate passers which need more than one // pawn push to become passed, or have a pawn in front of them. if ( !pos.pawn_passed(Us, s + Up) || (pos.pieces(PAWN) & (s + Up))) bonus = bonus / 2; score += bonus - PassedFile * std::min(file_of(s), File(pos.max_file() - file_of(s))); } // Scale by maximum promotion piece value Value maxMg = VALUE_ZERO, maxEg = VALUE_ZERO; for (PieceType pt : pos.promotion_piece_types()) { maxMg = std::max(maxMg, PieceValue[MG][pt]); maxEg = std::max(maxEg, PieceValue[EG][pt]); } score = make_score(mg_value(score) * int(maxMg - PawnValueMg) / (QueenValueMg - PawnValueMg), eg_value(score) * int(maxEg - PawnValueEg) / (QueenValueEg - PawnValueEg)); // Score passed shogi pawns const Square* pl = pos.squares(Us, SHOGI_PAWN); Square s; PieceType pt = pos.promoted_piece_type(SHOGI_PAWN); if (pt != NO_PIECE_TYPE) { while ((s = *pl++) != SQ_NONE) { if ((pos.pieces(Them, SHOGI_PAWN) & forward_file_bb(Us, s)) || relative_rank(Us, s, pos.max_rank()) == pos.max_rank()) continue; Square blockSq = s + Up; int d = std::max(pos.promotion_rank() - relative_rank(Us, s, pos.max_rank()), 1); d += !!(attackedBy[Them][ALL_PIECES] & ~attackedBy2[Us] & blockSq); score += make_score(PieceValue[MG][pt], PieceValue[EG][pt]) / (4 * d * d); } } if (T) Trace::add(PASSED, Us, score); return score; } // Evaluation::space() computes the space evaluation for a given side. The // space evaluation is a simple bonus based on the number of safe squares // available for minor pieces on the central four files on ranks 2--4. Safe // squares one, two or three squares behind a friendly pawn are counted // twice. Finally, the space bonus is multiplied by a weight. The aim is to // improve play on game opening. template template Score Evaluation::space() const { bool pawnsOnly = !(pos.pieces(Us) ^ pos.pieces(Us, PAWN)); if (pos.non_pawn_material() < SpaceThreshold && !pos.captures_to_hand() && !pawnsOnly) return SCORE_ZERO; constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Down = -pawn_push(Us); constexpr Bitboard SpaceMask = Us == WHITE ? CenterFiles & (Rank2BB | Rank3BB | Rank4BB) : CenterFiles & (Rank7BB | Rank6BB | Rank5BB); // Find the available squares for our pieces inside the area defined by SpaceMask Bitboard safe = SpaceMask & ~pos.pieces(Us, PAWN, SHOGI_PAWN) & ~attackedBy[Them][PAWN] & ~attackedBy[Them][SHOGI_PAWN]; // Find all squares which are at most three squares behind some friendly pawn Bitboard behind = pos.pieces(Us, PAWN, SHOGI_PAWN); behind |= shift(behind); behind |= shift(behind); if (pawnsOnly) { safe = behind & ~attackedBy[Them][ALL_PIECES]; behind = 0; } int bonus = popcount(safe) + popcount(behind & safe & ~attackedBy[Them][ALL_PIECES]); int weight = pos.count(Us) - 1; Score score = make_score(bonus * weight * weight / 16, 0); if (pos.capture_the_flag(Us)) score += make_score(200, 200) * popcount(behind & safe & pos.capture_the_flag(Us)); if (T) Trace::add(SPACE, Us, score); return score; } // Evaluation::variant() computes variant-specific evaluation bonuses for a given side. template template Score Evaluation::variant() const { constexpr Color Them = ~Us; constexpr Direction Down = pawn_push(Them); Score score = SCORE_ZERO; // Capture the flag if (pos.capture_the_flag(Us)) { PieceType ptCtf = pos.capture_the_flag_piece(); Bitboard ctfPieces = pos.pieces(Us, ptCtf); Bitboard ctfTargets = pos.capture_the_flag(Us) & pos.board_bb(); Bitboard onHold = 0; Bitboard onHold2 = 0; Bitboard processed = 0; // Traverse all paths of the CTF pieces to the CTF targets. // Put squares that are attacked or occupied on hold for one iteration. for (int dist = 0; (ctfPieces || onHold || onHold2) && (ctfTargets & ~processed); dist++) { int wins = popcount(ctfTargets & ctfPieces); if (wins) score += make_score(4000, 4000) * wins / (wins + dist * dist); Bitboard current = ctfPieces & ~ctfTargets; processed |= ctfPieces; ctfPieces = onHold & ~processed; onHold = onHold2 & ~processed; onHold2 = 0; while (current) { Square s = pop_lsb(¤t); Bitboard attacks = ( (PseudoAttacks[Us][ptCtf][s] & pos.pieces()) | (PseudoMoves[Us][ptCtf][s] & ~pos.pieces())) & ~processed & pos.board_bb(); ctfPieces |= attacks & ~(pos.pieces(Us, PAWN) | attackedBy[Them][ALL_PIECES]); onHold |= attacks & ~((pos.pieces(Us, PAWN) & (shift(pos.pieces()) | attackedBy[Them][ALL_PIECES])) | attackedBy2[Them]); onHold2 |= attacks; } } } // nCheck if (pos.check_counting()) { int remainingChecks = pos.checks_remaining(Us); assert(remainingChecks > 0); score += make_score(3600, 1000) / (remainingChecks * remainingChecks); } // Extinction if (pos.extinction_value() != VALUE_NONE) { for (PieceType pt : pos.extinction_piece_types()) if (pt != ALL_PIECES) { int denom = std::max(pos.count(Us, pt) - pos.extinction_piece_count(), 1); if (pos.count(Them, pt) >= pos.extinction_opponent_piece_count() || pos.two_boards()) score += make_score(1000000 / (500 + PieceValue[MG][pt]), 1000000 / (500 + PieceValue[EG][pt])) / (denom * denom) * (pos.extinction_value() / VALUE_MATE); } else if (pos.extinction_value() == VALUE_MATE && !pos.count(Us)) score += make_score(5000, pos.non_pawn_material(Us)) / pos.count(Us); } // Connect-n if (pos.connect_n() > 0) { for (Direction d : {NORTH, NORTH_EAST, EAST, SOUTH_EAST}) { // Find sufficiently large gaps Bitboard b = pos.board_bb() & ~pos.pieces(Them); for (int i = 1; i < pos.connect_n(); i++) b &= shift(d, b); // Count number of pieces per gap while (b) { Square s = pop_lsb(&b); int c = 0; for (int j = 0; j < pos.connect_n(); j++) if (pos.pieces(Us) & (s - j * d)) c++; score += make_score(200, 200) * c / (pos.connect_n() - c) / (pos.connect_n() - c); } } } if (T) Trace::add(VARIANT, Us, score); return score; } // Evaluation::initiative() computes the initiative correction value // for the position. It is a second order bonus/malus based on the // known attacking/defending status of the players. template Score Evaluation::initiative(Score score) const { Value mg = mg_value(score); Value eg = eg_value(score); // No initiative bonus for extinction variants if (pos.extinction_value() != VALUE_NONE || pos.captures_to_hand() || pos.connect_n()) return SCORE_ZERO; int outflanking = !pos.count(WHITE) || !pos.count(BLACK) ? 0 : distance(pos.square(WHITE), pos.square(BLACK)) - distance(pos.square(WHITE), pos.square(BLACK)); bool infiltration = (pos.count(WHITE) && rank_of(pos.square(WHITE)) > RANK_4) || (pos.count(BLACK) && rank_of(pos.square(BLACK)) < RANK_5); bool pawnsOnBothFlanks = (pos.pieces(PAWN) & QueenSide) && (pos.pieces(PAWN) & KingSide); bool almostUnwinnable = !pe->passed_count() && outflanking < 0 && pos.stalemate_value() == VALUE_DRAW && !pawnsOnBothFlanks; // Compute the initiative bonus for the attacking side int complexity = 9 * pe->passed_count() + 11 * pos.count() + 15 * pos.count() + 9 * outflanking + 12 * infiltration + 21 * pawnsOnBothFlanks + 51 * !pos.non_pawn_material() - 43 * almostUnwinnable - 100 ; // Now apply the bonus: note that we find the attacking side by extracting the // sign of the midgame or endgame values, and that we carefully cap the bonus // so that the midgame and endgame scores do not change sign after the bonus. int u = ((mg > 0) - (mg < 0)) * std::max(std::min(complexity + 50, 0), -abs(mg)); int v = ((eg > 0) - (eg < 0)) * std::max(complexity, -abs(eg)); if (T) Trace::add(INITIATIVE, make_score(u, v)); return make_score(u, v); } // Evaluation::scale_factor() computes the scale factor for the winning side template ScaleFactor Evaluation::scale_factor(Value eg) const { Color strongSide = eg > VALUE_DRAW ? WHITE : BLACK; int sf = me->scale_factor(pos, strongSide); // If scale is not already specific, scale down the endgame via general heuristics if (sf == SCALE_FACTOR_NORMAL && !pos.captures_to_hand()) { if ( pos.opposite_bishops() && pos.non_pawn_material() == 2 * BishopValueMg) sf = 22 ; else sf = std::min(sf, 36 + (pos.opposite_bishops() ? 2 : 7) * (pos.count(strongSide) + pos.count(strongSide))); sf = std::max(0, sf - (pos.rule50_count() - 12) / 4); } return ScaleFactor(sf); } // Evaluation::value() is the main function of the class. It computes the various // parts of the evaluation and returns the value of the position from the point // of view of the side to move. template Value Evaluation::value() { assert(!pos.checkers()); assert(!pos.is_immediate_game_end()); // Probe the material hash table me = Material::probe(pos); // If we have a specialized evaluation function for the current material // configuration, call it and return. if (me->specialized_eval_exists()) return me->evaluate(pos); // Initialize score by reading the incrementally updated scores included in // the position object (material + piece square tables) and the material // imbalance. Score is computed internally from the white point of view. Score score = pos.psq_score(); if (T) Trace::add(MATERIAL, score); score += me->imbalance() + pos.this_thread()->contempt; // Probe the pawn hash table pe = Pawns::probe(pos); score += pe->pawn_score(WHITE) - pe->pawn_score(BLACK); // Early exit if score is high Value v = (mg_value(score) + eg_value(score)) / 2; if (abs(v) > LazyThreshold + pos.non_pawn_material() / 64 && Options["UCI_Variant"] == "chess") return pos.side_to_move() == WHITE ? v : -v; // Main evaluation begins here initialize(); initialize(); // Pieces should be evaluated first (populate attack tables). // For unused piece types, we still need to set attack bitboard to zero. for (PieceType pt = KNIGHT; pt < KING; ++pt) if (pt != SHOGI_PAWN) score += pieces(pt) - pieces(pt); // Evaluate pieces in hand once attack tables are complete if (pos.piece_drops() || pos.seirawan_gating()) for (PieceType pt = PAWN; pt < KING; ++pt) score += hand(pt) - hand(pt); score += (mobility[WHITE] - mobility[BLACK]) * (1 + pos.captures_to_hand() + pos.must_capture()); score += king< WHITE>() - king< BLACK>() + threats() - threats() + passed< WHITE>() - passed< BLACK>() + space< WHITE>() - space< BLACK>() + variant() - variant(); score += initiative(score); // Interpolate between a middlegame and a (scaled by 'sf') endgame score ScaleFactor sf = scale_factor(eg_value(score)); v = mg_value(score) * int(me->game_phase()) + eg_value(score) * int(PHASE_MIDGAME - me->game_phase()) * sf / SCALE_FACTOR_NORMAL; v /= PHASE_MIDGAME; // In case of tracing add all remaining individual evaluation terms if (T) { Trace::add(IMBALANCE, me->imbalance()); Trace::add(PAWN, pe->pawn_score(WHITE), pe->pawn_score(BLACK)); Trace::add(MOBILITY, mobility[WHITE], mobility[BLACK]); Trace::add(TOTAL, score); } return (pos.side_to_move() == WHITE ? v : -v) // Side to move point of view + Eval::tempo_value(pos); } } // namespace /// tempo_value() returns the evaluation offset for the side to move Value Eval::tempo_value(const Position& pos) { return Tempo * (1 + 4 * pos.captures_to_hand()); } /// evaluate() is the evaluator for the outer world. It returns a static /// evaluation of the position from the point of view of the side to move. Value Eval::evaluate(const Position& pos) { return Evaluation(pos).value(); } /// trace() is like evaluate(), but instead of returning a value, it returns /// a string (suitable for outputting to stdout) that contains the detailed /// descriptions and values of each evaluation term. Useful for debugging. std::string Eval::trace(const Position& pos) { if (pos.checkers()) return "Total evaluation: none (in check)"; std::memset(scores, 0, sizeof(scores)); pos.this_thread()->contempt = SCORE_ZERO; // Reset any dynamic contempt Value v = Evaluation(pos).value(); v = pos.side_to_move() == WHITE ? v : -v; // Trace scores are from white's point of view std::stringstream ss; ss << std::showpoint << std::noshowpos << std::fixed << std::setprecision(2) << " Term | White | Black | Total \n" << " | MG EG | MG EG | MG EG \n" << " ------------+-------------+-------------+------------\n" << " Material | " << Term(MATERIAL) << " Imbalance | " << Term(IMBALANCE) << " Pawns | " << Term(PAWN) << " Knights | " << Term(KNIGHT) << " Bishops | " << Term(BISHOP) << " Rooks | " << Term(ROOK) << " Queens | " << Term(QUEEN) << " Mobility | " << Term(MOBILITY) << " King safety | " << Term(KING) << " Threats | " << Term(THREAT) << " Passed | " << Term(PASSED) << " Space | " << Term(SPACE) << " Initiative | " << Term(INITIATIVE) << " Variant | " << Term(VARIANT) << " ------------+-------------+-------------+------------\n" << " Total | " << Term(TOTAL); ss << "\nTotal evaluation: " << to_cp(v) << " (white side)\n"; return ss.str(); } Fairy-Stockfish-fairy_sf_11_1/src/evaluate.h000066400000000000000000000023611366242550200211610ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef EVALUATE_H_INCLUDED #define EVALUATE_H_INCLUDED #include #include "types.h" class Position; namespace Eval { constexpr Value Tempo = Value(28); // Must be visible to search std::string trace(const Position& pos); Value tempo_value(const Position& pos); Value evaluate(const Position& pos); } #endif // #ifndef EVALUATE_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/magic.h000066400000000000000000001322671366242550200204440ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #ifndef MAGIC_H_INCLUDED #define MAGIC_H_INCLUDED #ifdef PRECOMPUTED_MAGICS #define B(a, b) (Bitboard(a) << 64) ^ Bitboard(b) // Use precomputed magics if pext is not avaible, // since the magics generation is very slow. Bitboard RookMagicHInit[SQUARE_NB] = { B(0x120000880110000, 0x1008000000020020), B(0x24200C080840A052, 0x2004004000010008), B(0xC030024000228800, 0x4000010400000020), B(0x1A0020802008802, 0x206010208000), B(0x12002000D001024, 0x80100800090138), B(0x4220010000241010, 0x3098000602001500), B(0x401010004801040, 0x8000280480100000), B(0x820082024921836, 0x220028000), B(0x100400502411400, 0x220402120240D14), B(0x880202020010404, 0xA80202510000), B(0x140002801000018, 0x1000346490040), B(0x120000880110000, 0x1008000000020020), B(0xD01004008030400, 0x104000408104420), B(0x8420060100020000, 0x800280400000120), B(0x4010020018010, 0x40A00001100000), B(0x40006A0004000200, 0x40000000110), B(0xD01004008030400, 0x104000408104420), B(0x8908A20028110011, 0x800080000001A114), B(0x200042000080F009, 0x20001000004000), B(0x2820008820100, 0x10002400058000B9), B(0x6083100420008050, 0x4040012600280080), B(0x216020000000446, 0x4080204000000211), B(0x340140003002089, 0x2402008000000911), B(0xD01004008030400, 0x104000408104420), B(0x1404040B20001000, 0x8000824010800011), B(0x8C0488120024214, 0x8414880202291), B(0x1010000060050000, 0x4000004050002602), B(0x4022983A0060000, 0x80000040010400), B(0x1404040B20001000, 0x8000824010800011), B(0x6020101802002840, 0x31000003000004), B(0x9000420008840, 0x4881300000000210), B(0xA200808865, 0x41C0048023000128), B(0x31801100400000, 0x8802DC001221240), B(0x884000080200920, 0x1004002410401001), B(0x2400040000884, 0x421006208040C0), B(0x1404040B20001000, 0x8000824010800011), B(0x24100400060009, 0x112008025042410), B(0x1800040009040200, 0x180000A1004E408A), B(0x24100400060009, 0x112008025042410), B(0x4060402008080, 0xC240080000110000), B(0x20080100920020, 0x2002248010242052), B(0x10001010802050, 0x880000001C98420), B(0x4000800100420022, 0x502022010A00D0), B(0x4C18104500200885, 0x400880800), B(0x8080810081020090, 0x8000000000000), B(0x8000062812080201, 0x8004C8300800), B(0xC010220920198, 0x85000A08000), B(0x24100400060009, 0x112008025042410), B(0x80102204040, 0x1000000900000000), B(0x2080000004202804, 0x120880003461), B(0x102004090A4030, 0x801020589240), B(0x20001100814000A0, 0x420202000820004), B(0x100800000A000120, 0x208000800010000), B(0x1008205000040802, 0x80002000400040), B(0x1480000098008401, 0xA0010000581010), B(0x30C0008200100820, 0x102800080904834), B(0x4810821884000500, 0x4400000200000212), B(0x1811D00128A0180, 0x2500848803000000), B(0x41618A0300040040, 0x21200200A421801), B(0x80102204040, 0x1000000900000000), B(0xA1808E0100108000, 0x2008000505000002), B(0x8C890020410000A0, 0xA010000048000400), B(0x40006002210044, 0x600008000408000), B(0x1200447220090042, 0x80001000160012), B(0x48410010AB000000, 0x9200600000000100), B(0x2040000000240003, 0x8020080288000600), B(0x9080000088848088, 0x4010210500000041), B(0xA1808E0100108000, 0x2008000505000002), B(0x480100400024, 0x1004800018200000), B(0x808403080080200, 0x802601000000500), B(0x8C890020410000A0, 0xA010000048000400), B(0xA1808E0100108000, 0x2008000505000002), B(0x100A40000004008, 0x2800200400200480), B(0x100A40000004008, 0x2800200400200480), B(0x400014006000000, 0x10006000810001F5), B(0xC410062001414, 0x820080041B01044), B(0x20000800310, 0x430040000201000), B(0xA40010008000008, 0x4002200028000040), B(0xC00102000008021C, 0x10C2000A010E024), B(0x80004200104008, 0x50A00800C400020), B(0x20200080012542, 0x910F0040000402C0), B(0xB040100504000300, 0x24802002000040), B(0x800001000014008, 0x400031004000), B(0x100A40000004008, 0x2800200400200480), B(0x84008002041081C0, 0x8080500200000000), B(0x440090001012001, 0x4020004010), B(0x100A0028088020, 0x80040E00010020), B(0x2180808000810, 0xB018040A00040000), B(0x40C80920304C4001, 0x42800B200800000), B(0x85000425001000, 0x4810048020001100), B(0x600C000801000004, 0x8015084010200020), B(0x20020050000240C0, 0x100202008600800), B(0x38000050001220, 0x9200010200145900), B(0x1042108040005, 0x1402A0802201001), B(0x824240000C20400, 0x1000000400080010), B(0x84008002041081C0, 0x8080500200000000), B(0x400804A1000008, 0x1024104A0200010), B(0x8000402308483, 0x20006020100100), B(0x80880120000080, 0x8000240100084), B(0x5840020004882001, 0x1004528000A00010), B(0x8001018800300002, 0x84010040804), B(0x180D10004000A008, 0xA001080008020004), B(0x400080B, 0x10A0000004010000), B(0x8080000200000, 0x2001000082004E0), B(0x40040001000C2000, 0x2024800001004008), B(0x400804A1000008, 0x1024104A0200010), B(0x8000402308483, 0x20006020100100), B(0x400804A1000008, 0x1024104A0200010), B(0x2000200000, 0x1201011000802), B(0x100100000000C4, 0x208004084048201), B(0x400084000044, 0x100810140300), B(0x29040C0C01010, 0x300204010820080), B(0x1A808000020200, 0x1000000005210040), B(0x20000400150000, 0x85008020), B(0x40C040008184014, 0x8002AA00024010), B(0x202000081B00804, 0x10001002008), B(0x40011000210060, 0x6080C40000021004), B(0x2000200000, 0x1201011000802), B(0x4100480203840, 0x300080100804), B(0x2000200000, 0x1201011000802), }; Bitboard RookMagicVInit[SQUARE_NB] = { B(0x202000812104400, 0x24800B01C0000303), B(0x340020400010D, 0x88060150C00400), B(0x400802040609, 0x49010200501A0002), B(0x8002680301000208, 0x628006C0C020200), B(0x20400209001C0804, 0xA044000800143110), B(0xC400082060010202, 0x4000480401014000), B(0x22500200144040, 0x8204820084704C00), B(0x8C1204009030020, 0x328400805000000), B(0x84800800D0001640, 0x200080040060108), B(0x804810208020040, 0x140010108020000), B(0x1102010B008004, 0x300208006220020), B(0x140080404A0A2428, 0x6308010100080), B(0x20444002120408, 0xA080010508010001), B(0x82011044000D02, 0x4112028620110809), B(0x81010831000C02, 0x408802085000000), B(0x81010831000C02, 0x408802085000000), B(0x920008920600040, 0x8053801004000028), B(0x81140283208300, 0x10040C004200420), B(0x103080022201, 0xC01000081312620), B(0x2200221100008, 0x1000408104000A4), B(0x4402088080042008, 0x210401501040340), B(0x898400202170001, 0x80040404208000), B(0x20080004051012, 0x5100048200081800), B(0x2320020000401018, 0x108501021040210), B(0x21080410A422021, 0x83040180008800), B(0x44E8100000408224, 0x20010008040400), B(0x1800240002810405, 0x23004820000020), B(0x80A0100400110, 0x80104020100C4028), B(0x1002050001222C0, 0x5100818004024020), B(0x104000200040, 0xC010A09800102000), B(0x1020003A058120, 0x450900809000302), B(0x40040045008B1, 0x202800400383010), B(0x4640200220034, 0x8800485420304000), B(0x5001042100084288, 0x110820001240080A), B(0x2002C04004010120, 0xA15008020880001), B(0x2800004080C4190, 0x890808280020080), B(0x40C0401000104000, 0x2020880008002580), B(0x40020C002400802, 0x801104010000000), B(0x44842000040080, 0x2050011084000400), B(0x4110040800000401, 0x2023810029008000), B(0x20884000840, 0x8017102004008000), B(0x10411104000480, 0x1414042000201001), B(0x220040000008, 0x800306021000000), B(0x41400A0008080, 0x501000298ACAD10), B(0x800240012831810, 0x80120004468050E), B(0x800005020801008, 0x20102400240000), B(0x20C00040C114C010, 0x88080820200C00), B(0x1044010100820081, 0x20080841004000), B(0x8041048400022, 0x8020836040005002), B(0x2001004010205, 0x8001002884042009), B(0x128088400087, 0x20008002201002), B(0x8084108040402000, 0x80809000A080400), B(0x408081840880, 0x201002088000040), B(0xA40180010280, 0x241004006000010), B(0x4204100080048140, 0x2002C4F104202020), B(0x100140A10204, 0x980200800840060), B(0x1005140010202048, 0x1442280800202815), B(0x2000082025008600, 0x1108400040600003), B(0x1005050648000, 0x200020240008002), B(0x202010208044000, 0x8210404060008), B(0x8011040402000210, 0xC840180408016004), B(0x404098801028, 0x80020A0001000400), B(0x404098801028, 0x80020A0001000400), B(0x80101002180140, 0x40C2080820000C0), B(0x208202081260800, 0x14090E4C04000050), B(0x4221201084004C2, 0x110480A011060), B(0x8000008421090204, 0x1C01010800024), B(0x8000008421090204, 0x1C01010800024), B(0x200180C840088A0, 0x401100400820000), B(0x10084043A021070, 0x202041600080200), B(0x210E6202001040C, 0x10100800080B0), B(0x848008021204002, 0x801004308100BAD), B(0xC082C0390A000601, 0x4040080189008), B(0x431200240210402D, 0x58102820000), B(0x202020100A0019B0, 0x4010C0D018000000), B(0x800800908402203, 0x102948C84C184), B(0x26801100080845, 0x4009702022A00820), B(0x8880520010401040, 0x1060084832052000), B(0x100100022042081, 0x10000600008C121), B(0x46020384100040, 0x800200320882021), B(0xC0002010148, 0x4200800800040003), B(0x2002208020090040, 0x40820210021410), B(0x9000A41160002004, 0x2A09000100080043), B(0x800004010008001, 0x1108002020104600), B(0x800540C000A4E041, 0x18021180000401), B(0x808200900A900202, 0x8364202140012005), B(0x1DBA52000081010, 0x4008000023000010), B(0x4100110204401481, 0x800040091020001C), B(0x4100110204401481, 0x800040091020001C), B(0x4101100020400482, 0x2000402302100120), B(0x100408000A020212, 0xA000400111000020), B(0x2000010488080104, 0x3000404410208100), B(0x2684220180008DD0, 0x422040200004000A), B(0x2021200C0424, 0x1010100000080200), B(0x8908020020801006, 0x3010800020C2000), B(0x4000030008062044, 0x244010202688000), B(0x242101200408009, 0x8150040000200015), B(0x42004C02180204, 0x210208014241040), B(0x4E1A01C208410804, 0x8890041000012004), B(0x2080200401000080, 0x8001098429008004), B(0xA01400121804104, 0x280200C400000500), B(0xD0080408040420, 0x1006040100224000), B(0x28400205000800C9, 0x6021101401040075), B(0x4000900040020104, 0x88129801100D0C), B(0x8000004002180410, 0x400380200400204), B(0x4002A430043008, 0x400200340100020), B(0x401960004140A42, 0x100880710000464), B(0x58014090102, 0xB8D30004010080), B(0xA004C08000244000, 0x11280100E0000040), B(0x2102008089208804, 0x110001004080040), B(0x700010084E003004, 0x8080864112000D40), B(0x4080881000200C20, 0x30324040880E0600), B(0x2024A40401810820, 0x3000888002000000), B(0x8200100400014, 0x4400340800252844), B(0x24A00804288281, 0x410103002201140), B(0x4080005022A08, 0x1000402200100264), B(0x200080032244040, 0x200502189010001), B(0x28108110404001, 0x400600120008412), B(0xA00002102810020, 0xB1080240015408), B(0x810080200806, 0x410440804080046) }; Bitboard BishopMagicInit[SQUARE_NB] = { B(0x2001040305000010, 0x830200040400082), B(0x1042400080E01200, 0x2004904010811400), B(0x400010120200, 0x880080D080018000), B(0x240190C00100040, 0x100A020140044404), B(0x1018010404010004, 0x1001010018081E0), B(0x41200A804C0904, 0x40000322000008), B(0x4001180A004, 0x8000001106000000), B(0x6006020020030600, 0x1840002100004841), B(0x4200200100, 0x4001041808002000), B(0x4100020050124600, 0x1001802902400CA0), B(0x448C0081440161, 0x200206010008000), B(0x400008008008408, 0x1000080210100080), B(0x200280C01008200, 0x210200813000080), B(0x1A000204400, 0x222200401023000), B(0x10081040640A00, 0x8410021881400000), B(0x1840400318080008, 0x800800840080000), B(0x4204050C040, 0x6500600200140000), B(0x1012100040204, 0x402404444400000), B(0x6000012680008240, 0x410140000004220), B(0x1000020810040008, 0x2D0011000060000), B(0x1020020400, 0x400108059001001), B(0x400020001100808, 0x480204800200000B), B(0x10000010030084, 0x2042000848900022), B(0x10000010030084, 0x2042000848900022), B(0x100D801402400, 0x1512404009000400), B(0x8000208005112400, 0xA02040401000000), B(0x1000420002800200, 0x4CA000183020000), B(0x800811480020, 0x408801010224001), B(0xC805200810900100, 0x9000084204004020), B(0x8200160204100004, 0x8040004004002022), B(0x104514013080080, 0x146410040001000), B(0x140844000080002, 0x1008102020040001), B(0x4040400041A2002, 0x8040000A8802510), B(0x801014041008002, 0x80068008025200), B(0xA00540A414040, 0x4101040010A0000), B(0x6484008010810002, 0x1100506884024000), B(0x2800401008006000, 0x1005420884029020), B(0x6822091010004421, 0x2000458080480), B(0x40101000200101, 0x10020100001C4E0), B(0x100400008C42, 0x4000100009008000), B(0x851220018800400, 0x1681800040080080), B(0x64200002010, 0x900020200040002), B(0x20800080000022, 0x80040810002010), B(0xA88408000802080, 0x20808001000000), B(0x200000400C005040, 0x100140020290108), B(0x224100000800408, 0x4204802004400020), B(0x80080620010210, 0x91080088804040), B(0x4008002100010, 0x80AC201001000001), B(0x10008200902C046, 0x8080D03004000010), B(0x3002100081000180, 0x2210002121528408), B(0x8C101800804420, 0x1019880200043008), B(0x200022000920D0, 0x8000800081300020), B(0x1D40800880000, 0x400040001400050), B(0x2020004100040, 0x200008040008008), B(0x4840800040100001, 0x100100040203040), B(0x40084001105, 0x8800080088000089), B(0x4000128008020008, 0x4004200200440020), B(0x210040008520000, 0x820219001080022), B(0x1494040018002116, 0x400101047020008), B(0x510008001910C224, 0x80200148118000), B(0xC0301002301000, 0x4211A08004801), B(0x50008E0C01001080, 0x100C004102845100), B(0x400600020060400, 0x88024100250050), B(0x8202920002002040, 0x810012000003), B(0x800004208800200, 0x18AA00201000048), B(0x402100800100002, 0x411000081000400), B(0x101000022004044, 0x9000100040000), B(0x41068001001, 0xC00400010001), B(0x310210001040, 0x1A1200020010000), B(0xA082409200004048, 0x490040800124101), B(0x18844820E0040212, 0x1000404420D10000), B(0x802908A40003348, 0x20200040104140), B(0x1800404028205003, 0xC020010401089020), B(0x802100044D01000, 0x8C41888000800040), B(0x1D0161011410081, 0x10008000100200), B(0x401000480040100, 0x286800404002212), B(0x821030000100009, 0x2000090200A00000), B(0x200020800200800, 0x2000480900841012), B(0x80A000048030080, 0x200000120200008), B(0x40B1400008020020, 0x148000200008004), B(0xA021700002002010, 0x3040E400040100), B(0x400242C200200640, 0x20440210200281), B(0x80AC140040206240, 0x120000102801401), B(0x2020340040832040, 0x10402100A44000), B(0x420100400040220, 0x80014C8004000106), B(0x504300822421120, 0x8004004008400100), B(0x2001100008040, 0x2020104302000000), B(0xA500802000A, 0x2008008000114100), B(0x8A0020000200, 0x9C00101001002408), B(0x104000001001008, 0x9001000204040060), B(0x1000820080108200, 0xA401000008100001), B(0x2008600009000480, 0x9008020001400000), B(0x4000800200040200, 0xA00030400308082), B(0x4004300202004709, 0x1000100180010020), B(0xC014800100440010, 0x402020280002C010), B(0x220208010884680, 0x1040280000042110), B(0x40B0018019202801, 0x1008408000100040), B(0x8269010206080044, 0x8001810000000040), B(0x4000020880081040, 0x208A44000028000), B(0x4004004E9004220A, 0x2104004001400024), B(0x8035006008C0904, 0x402002001080120), B(0x1800884002, 0x404400820000000), B(0x8088000004008910, 0x8024100401000000), B(0x142200086000100, 0x28021040020002E), B(0x1000409141004018, 0x100410820080040A), B(0x1800801800140, 0x810801060C0801), B(0x1000C00100402220, 0x808023420000000), B(0x8A0A202414305008, 0x100040200000021), B(0xC0208024050, 0x8003088008020401), B(0x8044004201440101, 0x400820080C024022), B(0x406018884120099, 0xB00088018002000), B(0x2000800010403010, 0xC5A002002010010), B(0x800020040840, 0x201800202800200), B(0x201280120020008D, 0x258809001000040), B(0x9100002020181, 0x80400082204000), B(0x104010080201001, 0x40080080181080), B(0x8440248092000430, 0xA200804900100000), B(0x2031010C01000C20, 0x200310A560082008), B(0x400202081811400, 0x40081802050000C), B(0x1011002100821300, 0x2400825040804100) }; Bitboard CannonMagicHInit[SQUARE_NB] = { B(0x120000880110000, 0x1008000000020020), B(0x24200C080840A052, 0x2004004000010008), B(0xC030024000228800, 0x4000010400000020), B(0x1A0020802008802, 0x206010208000), B(0x12002000D001024, 0x80100800090138), B(0x4220010000241010, 0x3098000602001500), B(0x401010004801040, 0x8000280480100000), B(0x820082024921836, 0x220028000), B(0x100400502411400, 0x220402120240D14), B(0x880202020010404, 0xA80202510000), B(0x140002801000018, 0x1000346490040), B(0x120000880110000, 0x1008000000020020), B(0xD01004008030400, 0x104000408104420), B(0x8420060100020000, 0x800280400000120), B(0x4010020018010, 0x40A00001100000), B(0x40006A0004000200, 0x40000000110), B(0xD01004008030400, 0x104000408104420), B(0x8908A20028110011, 0x800080000001A114), B(0x200042000080F009, 0x20001000004000), B(0x2820008820100, 0x10002400058000B9), B(0x6083100420008050, 0x4040012600280080), B(0x216020000000446, 0x4080204000000211), B(0x340140003002089, 0x2402008000000911), B(0xD01004008030400, 0x104000408104420), B(0x1404040B20001000, 0x8000824010800011), B(0x8C0488120024214, 0x8414880202291), B(0x1010000060050000, 0x4000004050002602), B(0x4022983A0060000, 0x80000040010400), B(0x1404040B20001000, 0x8000824010800011), B(0x6020101802002840, 0x31000003000004), B(0x9000420008840, 0x4881300000000210), B(0xA200808865, 0x41C0048023000128), B(0x31801100400000, 0x8802DC001221240), B(0x884000080200920, 0x1004002410401001), B(0x2400040000884, 0x421006208040C0), B(0x1404040B20001000, 0x8000824010800011), B(0x24100400060009, 0x112008025042410), B(0x1800040009040200, 0x180000A1004E408A), B(0x24100400060009, 0x112008025042410), B(0x4060402008080, 0xC240080000110000), B(0x20080100920020, 0x2002248010242052), B(0x10001010802050, 0x880000001C98420), B(0x4000800100420022, 0x502022010A00D0), B(0x4C18104500200885, 0x400880800), B(0x8080810081020090, 0x8000000000000), B(0x8000062812080201, 0x8004C8300800), B(0x1800040009040200, 0x180000A1004E408A), B(0x24100400060009, 0x112008025042410), B(0x80102204040, 0x1000000900000000), B(0x2080000004202804, 0x120880003461), B(0x102004090A4030, 0x801020589240), B(0x20001100814000A0, 0x420202000820004), B(0x100800000A000120, 0x208000800010000), B(0x1008205000040802, 0x80002000400040), B(0x1480000098008401, 0xA0010000581010), B(0x30C0008200100820, 0x102800080904834), B(0x4810821884000500, 0x4400000200000212), B(0x1811D00128A0180, 0x2500848803000000), B(0x41618A0300040040, 0x21200200A421801), B(0x80102204040, 0x1000000900000000), B(0xA1808E0100108000, 0x2008000505000002), B(0x8C890020410000A0, 0xA010000048000400), B(0x40006002210044, 0x600008000408000), B(0x1200447220090042, 0x80001000160012), B(0x48410010AB000000, 0x9200600000000100), B(0x2040000000240003, 0x8020080288000600), B(0x9080000088848088, 0x4010210500000041), B(0xA1808E0100108000, 0x2008000505000002), B(0x480100400024, 0x1004800018200000), B(0x808403080080200, 0x802601000000500), B(0x8C890020410000A0, 0xA010000048000400), B(0xA1808E0100108000, 0x2008000505000002), B(0x100A40000004008, 0x2800200400200480), B(0x100A40000004008, 0x2800200400200480), B(0x400014006000000, 0x10006000810001F5), B(0xC410062001414, 0x820080041B01044), B(0x20000800310, 0x430040000201000), B(0xA40010008000008, 0x4002200028000040), B(0xC00102000008021C, 0x10C2000A010E024), B(0x80004200104008, 0x50A00800C400020), B(0x20200080012542, 0x910F0040000402C0), B(0xB040100504000300, 0x24802002000040), B(0x800001000014008, 0x400031004000), B(0x100A40000004008, 0x2800200400200480), B(0x84008002041081C0, 0x8080500200000000), B(0x440090001012001, 0x4020004010), B(0x100A0028088020, 0x80040E00010020), B(0x2180808000810, 0xB018040A00040000), B(0x40C80920304C4001, 0x42800B200800000), B(0x85000425001000, 0x4810048020001100), B(0x600C000801000004, 0x8015084010200020), B(0x20020050000240C0, 0x100202008600800), B(0x38000050001220, 0x9200010200145900), B(0x1042108040005, 0x1402A0802201001), B(0x824240000C20400, 0x1000000400080010), B(0x84008002041081C0, 0x8080500200000000), B(0x400804A1000008, 0x1024104A0200010), B(0x8000402308483, 0x20006020100100), B(0x80880120000080, 0x8000240100084), B(0x5840020004882001, 0x1004528000A00010), B(0x8001018800300002, 0x84010040804), B(0x180D10004000A008, 0xA001080008020004), B(0x400080B, 0x10A0000004010000), B(0x8080000200000, 0x2001000082004E0), B(0x40040001000C2000, 0x2024800001004008), B(0x400804A1000008, 0x1024104A0200010), B(0x8000402308483, 0x20006020100100), B(0x400804A1000008, 0x1024104A0200010), B(0x2000200000, 0x1201011000802), B(0x100100000000C4, 0x208004084048201), B(0x400084000044, 0x100810140300), B(0x29040C0C01010, 0x300204010820080), B(0x1A808000020200, 0x1000000005210040), B(0x20000400150000, 0x85008020), B(0x40C040008184014, 0x8002AA00024010), B(0x202000081B00804, 0x10001002008), B(0x40011000210060, 0x6080C40000021004), B(0x2000200000, 0x1201011000802), B(0x4100480203840, 0x300080100804), B(0x2000200000, 0x1201011000802), }; Bitboard CannonMagicVInit[SQUARE_NB] = { B(0x202000812104400, 0x24800B01C0000303), B(0x340020400010D, 0x88060150C00400), B(0x400802040609, 0x49010200501A0002), B(0x8002680301000208, 0x628006C0C020200), B(0x20400209001C0804, 0xA044000800143110), B(0xC400082060010202, 0x4000480401014000), B(0x22500200144040, 0x8204820084704C00), B(0x8C1204009030020, 0x328400805000000), B(0x84800800D0001640, 0x200080040060108), B(0x804810208020040, 0x140010108020000), B(0x1102010B008004, 0x300208006220020), B(0x140080404A0A2428, 0x6308010100080), B(0x20444002120408, 0xA080010508010001), B(0x82011044000D02, 0x4112028620110809), B(0x81010831000C02, 0x408802085000000), B(0x81010831000C02, 0x408802085000000), B(0x920008920600040, 0x8053801004000028), B(0x81140283208300, 0x10040C004200420), B(0x103080022201, 0xC01000081312620), B(0x2200221100008, 0x1000408104000A4), B(0x4402088080042008, 0x210401501040340), B(0x898400202170001, 0x80040404208000), B(0x20080004051012, 0x5100048200081800), B(0x2320020000401018, 0x108501021040210), B(0x21080410A422021, 0x83040180008800), B(0x44E8100000408224, 0x20010008040400), B(0x1800240002810405, 0x23004820000020), B(0x80A0100400110, 0x80104020100C4028), B(0x1002050001222C0, 0x5100818004024020), B(0x104000200040, 0xC010A09800102000), B(0x1020003A058120, 0x450900809000302), B(0x40040045008B1, 0x202800400383010), B(0x4640200220034, 0x8800485420304000), B(0x5001042100084288, 0x110820001240080A), B(0x2002C04004010120, 0xA15008020880001), B(0x2800004080C4190, 0x890808280020080), B(0x40C0401000104000, 0x2020880008002580), B(0x40020C002400802, 0x801104010000000), B(0x44842000040080, 0x2050011084000400), B(0x4110040800000401, 0x2023810029008000), B(0x20884000840, 0x8017102004008000), B(0x10411104000480, 0x1414042000201001), B(0x220040000008, 0x800306021000000), B(0x41400A0008080, 0x501000298ACAD10), B(0x800240012831810, 0x80120004468050E), B(0x800005020801008, 0x20102400240000), B(0x20C00040C114C010, 0x88080820200C00), B(0x1044010100820081, 0x20080841004000), B(0x8041048400022, 0x8020836040005002), B(0x2001004010205, 0x8001002884042009), B(0x128088400087, 0x20008002201002), B(0x8084108040402000, 0x80809000A080400), B(0x408081840880, 0x201002088000040), B(0xA40180010280, 0x241004006000010), B(0x4204100080048140, 0x2002C4F104202020), B(0x100140A10204, 0x980200800840060), B(0x1005140010202048, 0x1442280800202815), B(0x2000082025008600, 0x1108400040600003), B(0x1005050648000, 0x200020240008002), B(0x202010208044000, 0x8210404060008), B(0x8011040402000210, 0xC840180408016004), B(0x404098801028, 0x80020A0001000400), B(0x404098801028, 0x80020A0001000400), B(0x80101002180140, 0x40C2080820000C0), B(0x208202081260800, 0x14090E4C04000050), B(0x4221201084004C2, 0x110480A011060), B(0x8000008421090204, 0x1C01010800024), B(0x8000008421090204, 0x1C01010800024), B(0x200180C840088A0, 0x401100400820000), B(0x10084043A021070, 0x202041600080200), B(0x210E6202001040C, 0x10100800080B0), B(0x848008021204002, 0x801004308100BAD), B(0xC082C0390A000601, 0x4040080189008), B(0x431200240210402D, 0x58102820000), B(0x202020100A0019B0, 0x4010C0D018000000), B(0x800800908402203, 0x102948C84C184), B(0x26801100080845, 0x4009702022A00820), B(0x8880520010401040, 0x1060084832052000), B(0x100100022042081, 0x10000600008C121), B(0x46020384100040, 0x800200320882021), B(0xC0002010148, 0x4200800800040003), B(0x2002208020090040, 0x40820210021410), B(0x9000A41160002004, 0x2A09000100080043), B(0x800004010008001, 0x1108002020104600), B(0x800540C000A4E041, 0x18021180000401), B(0x808200900A900202, 0x8364202140012005), B(0x1DBA52000081010, 0x4008000023000010), B(0x4100110204401481, 0x800040091020001C), B(0x4100110204401481, 0x800040091020001C), B(0x4101100020400482, 0x2000402302100120), B(0x100408000A020212, 0xA000400111000020), B(0x2000010488080104, 0x3000404410208100), B(0x2684220180008DD0, 0x422040200004000A), B(0x2021200C0424, 0x1010100000080200), B(0x8908020020801006, 0x3010800020C2000), B(0x4000030008062044, 0x244010202688000), B(0x242101200408009, 0x8150040000200015), B(0x42004C02180204, 0x210208014241040), B(0x4E1A01C208410804, 0x8890041000012004), B(0x2080200401000080, 0x8001098429008004), B(0xA01400121804104, 0x280200C400000500), B(0xD0080408040420, 0x1006040100224000), B(0x28400205000800C9, 0x6021101401040075), B(0x4000900040020104, 0x88129801100D0C), B(0x8000004002180410, 0x400380200400204), B(0x4002A430043008, 0x400200340100020), B(0x401960004140A42, 0x100880710000464), B(0x58014090102, 0xB8D30004010080), B(0xA004C08000244000, 0x11280100E0000040), B(0x2102008089208804, 0x110001004080040), B(0x700010084E003004, 0x8080864112000D40), B(0x4080881000200C20, 0x30324040880E0600), B(0x2024A40401810820, 0x3000888002000000), B(0x8200100400014, 0x4400340800252844), B(0x24A00804288281, 0x410103002201140), B(0x4080005022A08, 0x1000402200100264), B(0x200080032244040, 0x200502189010001), B(0x28108110404001, 0x400600120008412), B(0xA00002102810020, 0xB1080240015408), B(0x810080200806, 0x410440804080046), }; Bitboard HorseMagicInit[SQUARE_NB] = { B(0x3C080482A592000C, 0x540104000020000), B(0x2802C40008000420, 0x4A00000001818009), B(0x1083040280804000, 0x120004C20100880), B(0x6840940880000892, 0x2014A01080800C2), B(0x8401489004000180, 0x2000800000400000), B(0x820161C800000110, 0x8000100000204020), B(0x610011A122000109, 0x1000004020008004), B(0x83282004023000, 0xE000020004848446), B(0x6840940880000892, 0x2014A01080800C2), B(0x4020120800800002, 0x88008000010020), B(0x30025B140A1000, 0x3141801401000040), B(0x41104D1810100050, 0x8141002010910), B(0x4200828A298400, 0x400340001040C000), B(0x8016A4900110040, 0x844812001068020), B(0x2250035820400A2, 0x8012010080900), B(0x820080083A009000, 0x880404091080110), B(0x80401500AF0020, 0x240000082201A04), B(0x668020020C081005, 0x4008001004100021), B(0x240100910000000, 0x82000A0030454000), B(0xA24091400008, 0x200014880004A921), B(0x840110042200410, 0x100080000A400000), B(0x40024024102000, 0x1000000002180404), B(0x92828423000530, 0x118800020110), B(0x1122404A1C90A8, 0x822040280020D00), B(0x41201A40900A000, 0x80C0480040605100), B(0x2504A85005488280, 0x3028112120022800), B(0x210180080626B048, 0x8000401000014000), B(0x1000410401040200, 0x41014000050C0106), B(0x1040650210802200, 0x80C0041000000), B(0x4020C10110900002, 0x2140C2001050009), B(0x191180092200022, 0x6010008400400800), B(0x8010821088080202, 0xCA240011008208), B(0x8C0488120024214, 0x8414880202291), B(0x8C0488120024214, 0x8414880202291), B(0x22080C8A0161401, 0x200C10004C002002), B(0x8430818023034080, 0x210090800000801), B(0x4845087008200, 0x40661480000), B(0x1202804428812050, 0x100022038020000), B(0x400016001201080, 0x24002200402060), B(0x680E041300800800, 0xE00130080004000), B(0x3409080200, 0x282840210000000), B(0x803310108400, 0x85200000080100A0), B(0xE180008A04162104, 0x9088240412404), B(0x20080100920020, 0x2002248010242052), B(0x8A000400C2410, 0x1000024086014300), B(0x1821040024663, 0x100000100010009), B(0x4000822310611, 0x120280406014008), B(0x1004008010818D08, 0x800000141892000), B(0x8010800004024042, 0x44B106008800896), B(0xA0063423444, 0x41002C15811008), B(0x2040012381001282, 0x4804080104A4000), B(0x10840101820880, 0xA800008000020020), B(0x10840101820880, 0xA800008000020020), B(0x60201D8300408190, 0x2010020920200000), B(0x4048100200090090, 0x2008090100000900), B(0x24200000280210, 0xD440050008004000), B(0x1280001000580020, 0x2200040089000A4), B(0x10208018C1020A20, 0x84C0432240610014), B(0x10208018C1020A20, 0x84C0432240610014), B(0x4108000010209089, 0x913000000024840), B(0x410C208008008E02, 0xE8000000000001), B(0x802208004005, 0x94206000022080), B(0xC00290018902002, 0x4204100000000000), B(0x2102801400093816, 0x9810004001000202), B(0x8008304000015800, 0x4A5C000000020000), B(0x1020108380800514, 0x1144210000000080), B(0xC0001000008090, 0x2812060000204000), B(0x1001100200003100, 0x246240060A004004), B(0xA00020A008002030, 0x2440C40000110B00), B(0x80502104000C008, 0x8222200042100010), B(0xC020200088014, 0x422094000000480), B(0x1029002000001030, 0x8105841120000210), B(0x49040D, 0x2310808A14042C0), B(0x200040200080A02C, 0xB890290400080000), B(0x2240180C0800002, 0x4151050280000100), B(0x2240180C0800002, 0x4151050280000100), B(0x8220224180420006, 0x4024501212011000), B(0x1806810A0881000, 0x802002048400080), B(0x400400A080842, 0x9305000401180000), B(0x10008001444110, 0x4420401040041833), B(0x2000002C02010E00, 0x400408D08009804), B(0x69D008200020100, 0x100842240049021), B(0x42C24450020000, 0xD38400880090884), B(0x485800800100001, 0x2484086522018840), B(0x900200020820042, 0x22302421400040C0), B(0x50B0413001818000, 0x452014040800C40), B(0x8004040021008, 0x20088A08000290), B(0x600C000801000004, 0x8015084010200020), B(0x208000C00, 0xE004804021100100), B(0x20001000040204, 0x948110C0B2081), B(0x268502400100021, 0x80A201840802080), B(0x408C000008, 0x8822102408014), B(0x1182080410100000, 0x608002046A0100), B(0x100820A083C00002, 0x3100100410A00), B(0x8401040000400124, 0x2000081288202200), B(0xB014040003000800, 0x11960D1101210), B(0x10040001900C000, 0x85603C1001280), B(0x2000844000000100, 0x2000024C60800800), B(0x120004234800900, 0x210010841040), B(0x8010300040000002, 0x4200008222104100), B(0x1000120402200100, 0x209080CC040108B4), B(0x110049A00000800, 0x80000420022180A8), B(0x80001C00080384, 0x1400101111081001), B(0x8011200008100428, 0x2020000880800922), B(0x10001000000204C8, 0x280C11104240), B(0x50100C82C000500, 0x28000280618DD1), B(0x8800498020000, 0x20500A0200320128), B(0x20010104000860, 0x8021720186008), B(0x4000000000100080, 0x35040084270C04), B(0x4500080000800, 0x280100002482C842), B(0x10400000000000, 0x20080051100130C2), B(0x10400000000000, 0x20080051100130C2), B(0x2000002110202014, 0x121004004004681), B(0x400202001006D40, 0x82240082202424), B(0x4500080000800, 0x280100002482C842), B(0xC6000000D00804, 0x1050020C0081090C), B(0x200080000000042, 0x10800661), B(0x2000001011200200, 0x2A420000802A0222), B(0x802020001202412, 0x2400404148426), B(0x8000440801040002, 0x444002800010052A), }; Bitboard ElephantMagicInit[SQUARE_NB] = { B(0x64D2990200008, 0x4401880001C000), B(0x29BAA00010020, 0x200000400800600), B(0x3024240000000, 0x4100400010080), B(0xA490A00480020, 0x20084001041010A4), B(0x328C021008042, 0x100000000C10204), B(0x1964090001018, 0x7002040148001205), B(0x800302098404080, 0x4983020000000001), B(0x8812244630A02080, 0x8200006204003C08), B(0x41120231008000, 0x240441401020), B(0x840091030C00040, 0x1400008200023400), B(0x8001040E77030200, 0x100040090022000), B(0x602022139D835040, 0x101002010025900), B(0x405707C48400, 0x40010000008001), B(0x982003456A82050, 0x60800820040030), B(0x204184849200088, 0x101800004006), B(0x300222470949200, 0x2A0800200200800), B(0x400001211914000, 0x8200001407001), B(0x2000008614831020, 0x4000020001404000), B(0x84000024A2048048, 0x1200102000042), B(0x424010A58422008, 0x88440242212A0110), B(0x20020812C0C4408, 0x4121400000080010), B(0x680200062042420, 0x2001100000800000), B(0x200010060AEC855, 0x8083002040200000), B(0x4000008BAA85810, 0x82000805C0200A90), B(0x81450B200A025400, 0x4400101050000040), B(0x820A2241409010, 0x888420030000), B(0x909203000028, 0xC000004C00200041), B(0x8021400A84880240, 0x100180002010020), B(0x8001A20061410000, 0x14008499A000000), B(0x8201444800A00080, 0x402010040588120), B(0x100C06280020, 0x60010104840130), B(0x520040800080044, 0x8220000080001402), B(0x102021410040202, 0x2004400410006000), B(0x5401832090020400, 0x300010020001), B(0x180003105A84C108, 0x1012008800081000), B(0x480C10210026904, 0xA006000004200418), B(0x48050820210843A6, 0x108001004000C00), B(0x1030101182206324, 0x4401008921502002), B(0x40281060800800, 0x406000201260022), B(0xC29002440040C820, 0x400001002008020), B(0x40000400800241, 0xC220000000400280), B(0x40880126014208, 0x2A8004C008940000), B(0x121028100114080, 0x5010280481100082), B(0x4000088280442, 0x908420140008041), B(0x808C42400C0020, 0x3028100840801000), B(0x4000000410078488, 0x501000000620000), B(0x90080001421020A4, 0x4118400101060406), B(0x280420004855, 0xD200100400820000), B(0xA0063423444, 0x41002C15811008), B(0x200061201808102, 0x4286969000200002), B(0x10208018C1020A20, 0x84C0432240610014), B(0x4001A04880402000, 0x8100824080000001), B(0x60201D8300408190, 0x2010020920200000), B(0x20018C04908019, 0x2010884002002040), B(0x800000000C40810, 0x680100081150000D), B(0x2002002000040040, 0x8810049000010600), B(0x41618A0300040040, 0x21200200A421801), B(0x10208018C1020A20, 0x84C0432240610014), B(0x10208018C1020A20, 0x84C0432240610014), B(0x5A04001400412854, 0x8A44006000010002), B(0x13000C0810072432, 0x50049001021104), B(0x400048801142130, 0x4C1204100226010C), B(0x80001048, 0x408800104000080), B(0x8104868204040412, 0x22244202000081), B(0x8104868204040412, 0x22244202000081), B(0x4140001000240440, 0x80209004410004E), B(0x800800000100, 0xB111820100000002), B(0x404240004220, 0x2110402802050080), B(0x284010400004040, 0x100245002502020), B(0x14880A100114010, 0x400208080010024), B(0x4100004040440648, 0x10030D838041A80), B(0x32004000210, 0x4010225C88014000), B(0x2240180C0800002, 0x4151050280000100), B(0x2010A12002000042, 0x189051442010000), B(0x4060050080121883, 0x8250C10001000141), B(0x10000000044100, 0x8401084010261009), B(0xA00028040000, 0x2003224000002000), B(0x2060009001000020, 0x1000432022020228), B(0x404200000883080, 0x1080800848245000), B(0x240000402080, 0xCA0820814210502), B(0x200040200080A02C, 0xB890290400080000), B(0x800000000300482, 0x9203008100100013), B(0x8000210202042000, 0x22642104004C2400), B(0x1040400805000401, 0x2A0300102C80010), B(0x8010A01088020000, 0x122106105A06A030), B(0x8000C00001010494, 0x130A1A20404120), B(0x4B084010844290, 0x10A08008900840), B(0x1180001802460000, 0xB08000034C82004), B(0x4001880060028029, 0x204040002401000), B(0x8021A0001308002A, 0x97001822040040), B(0xC00000009A020AC1, 0x1000080900400), B(0x60010110001990, 0x4000880900400000), B(0x10290402401200, 0x230080402C08), B(0x4220000219012000, 0x140204804100008), B(0x1400200100002, 0x8E62200414128), B(0x402808502004403, 0x20049100C0284520), B(0xB30041004280280, 0x10020464DB200308), B(0x440010800808, 0xA0102E295812100), B(0x10008000B000, 0x2000058583220200), B(0x2000844000000100, 0x2000024C60800800), B(0x110000400100028, 0x24052304508004), B(0x8458000000840004, 0x118006463400001), B(0x804008000040050, 0x41044890228000), B(0x20000050000400, 0x80A101824A00086), B(0x600080404000020, 0x100007322480005), B(0xD082200020020008, 0x642000630120001), B(0x10000100040230, 0x8048114733320002), B(0x20200442002A880A, 0x8200002CB4B8052), B(0x290080000000, 0xA41297838F40D), B(0x800205000080, 0xF221232039874400), B(0x1444002004880C20, 0xC4100049144200), B(0x4500080000800, 0x280100002482C842), B(0x281240881008, 0x204084004C101900), B(0x1444002004880C20, 0xC4100049144200), B(0x4500080000800, 0x280100002482C842), B(0xC0010928430540, 0x92041902180), B(0x1051001208A, 0x4900064800C20640), B(0x882020418C00000, 0x30004040092A821), B(0x224404002004268C, 0x202500204C7D254), B(0x290080000000, 0xA41297838F40D), }; Bitboard JanggiElephantMagicInit[SQUARE_NB] = { B(0xC502282200061400, 0x2D07081241D90200), B(0xC502282200061400, 0x2D07081241D90200), B(0x8084810022440C2, 0x81402202004), B(0x80204010A800500, 0x5000021001740218), B(0x8048100401208000, 0x2001000390000044), B(0x202080020000000, 0x4010800010090424), B(0x4081A0480073200, 0x100000A010406000), B(0x4081A0480073200, 0x100000A010406000), B(0x2040450004000C40, 0x8400000006302), B(0x84010410018201, 0xA00A00000100000), B(0x840091030C00040, 0x1400008200023400), B(0x801058C0A0022, 0xC1920480010034), B(0x80B4004800840800, 0x4080210A42040010), B(0x400402221000445, 0x80321200408040), B(0x4028142401012A00, 0x4005009000104448), B(0x1440102040800220, 0x82800010A082000), B(0x4100040300C00200, 0x800805100120000), B(0x8200080061100, 0x2000101400000), B(0x2000100410070001, 0x40818200B0900410), B(0x400088020080000, 0x4A000402000CA0), B(0x1402040410004000, 0x9840044504040), B(0x20800088A00A0400, 0x1000020100180), B(0x2001820520308201, 0x2008003404349000), B(0x4004808022100, 0x8001000008081080), B(0x102041041100425, 0x840400180B100104), B(0x8806446000800214, 0x404402100010000), B(0x8200141409C04101, 0x209030004A00D00), B(0x8806004800880080, 0x1560004201000A01), B(0x4200050600200090, 0x1CD0000000000421), B(0x4820100022408100, 0x101404080320), B(0x2A000A0A08080080, 0x1C02808000C2C0), B(0x8808425040040014, 0x2021000100020), B(0x5282104044A0020, 0x6B402104200008), B(0x4001091040068120, 0x202000004003031), B(0x4001091040068120, 0x202000004003031), B(0x98040200A0214344, 0xA00300840010), B(0x82508040A40808A, 0x40010000110042), B(0x4400100101023, 0x450C8480040022), B(0x210588880010800, 0x800A000108018102), B(0x9400010144400, 0xC00010100018000), B(0x20A0400100040004, 0x1242000101002040), B(0x8022900040001001, 0x100000014000260), B(0x51004124000A080, 0x40098400000002), B(0x2158040001080022, 0x80009238401222), B(0xA0103A0000802220, 0x20000200400010), B(0x1101001208240, 0x100000800001064), B(0x821020002090081, 0x5840D0010290280), B(0x821020002090081, 0x5840D0010290280), B(0x10400C1042000400, 0x4005000000440200), B(0x844022008804820, 0x1000800100118000), B(0x10802A9800800139, 0x4802840100842200), B(0x4000A008200081, 0x4001100200402000), B(0x200000008108400, 0x1000C00008080020), B(0x120C11500100081, 0x440300308041100), B(0x8080040080060100, 0xC00101B0040028), B(0x901420A00110000, 0x8200010044700280), B(0x140080080410000, 0x808040000C001001), B(0x80210C0200A0008, 0x88088004600201), B(0x8000004202020301, 0x2100142104002000), B(0x1101011210004880, 0x8500840400000000), B(0x40208802004800, 0x8080806009011240), B(0x800000140408880, 0xC001018004060040), B(0xC008080420500, 0x8024A10000000000), B(0x2800000000400010, 0x44001C00400408), B(0xA804008001200408, 0x202000020001000), B(0xC08288805004080, 0x200042000800004), B(0xA40A01000080012, 0x8800080042408), B(0x2200100000100810, 0x800200010000100), B(0x9881800004040001, 0x8058100100884004), B(0x820000044020014, 0x4AA00010245012), B(0x820000044020014, 0x4AA00010245012), B(0x4000080240000808, 0x10100022054000), B(0x5002000840101, 0x202020004000A00), B(0x1188008200008402, 0x8088100020A2204), B(0x304012004044080, 0x8028108818006010), B(0x102210000008400, 0x1008000200380002), B(0x51410E114200, 0x100C00084000000), B(0x5001242320218, 0x800025000040040), B(0x4008000200008190, 0x400020021000000), B(0x10910022F0040, 0x450084400040001), B(0x180010810000040, 0x4004100040040), B(0x1088801424062010, 0x400084010030401), B(0x3000120408000040, 0x10802001080A4051), B(0x200008420, 0x40C0100020008804), B(0x1048C000004000, 0x4220120804004000), B(0x404A180000000E, 0x4C30412008110102), B(0x400000404202005, 0x800808550EC40044), B(0x282000200212010, 0x8001C0C102000210), B(0x9012240000008100, 0x280CA04010040000), B(0x2000C04001020C00, 0x2002010101042000), B(0x1010000204408408, 0x8008004800E0C4A), B(0x800286801000025, 0x8402401040050088), B(0x40002000A0880000, 0x8400300108082086), B(0x2080004404011, 0x20C080400100001), B(0xB0010218100800, 0x8040200482C14103), B(0x8011035000000C20, 0x4200044043200040), B(0x804008000040050, 0x41044890228000), B(0x80000400A0020020, 0x5308022021000000), B(0x2118200000008004, 0x4141014004423D00), B(0x90C0000200008040, 0x41041062000082), B(0x1D000100941204, 0x12402001200420), B(0x8C0040400400065, 0x22300B408100000), B(0x8C0040400400065, 0x22300B408100000), B(0x802802044600000, 0x1210100401030082), B(0x9400488010000000, 0x8005404902040000), B(0x2214020200001, 0x40102100820200), B(0x2022000000800000, 0x6400440108480), B(0x110000400100028, 0x24052304508004), B(0x848820140010000, 0x201012500A000), B(0x848820140010000, 0x201012500A000), B(0x100100000000C4, 0x208004084048201), B(0x100500000000290, 0x10102818208000), B(0x2800414000C000, 0x20004005001301), B(0x698180005101241, 0x10002014800210), B(0x20000080000009, 0x440340C040), B(0x1C0220200290020, 0x42100004004011C0), B(0x200E620018320208, 0x440410402), B(0xD04101010004024, 0x20000121104010A4), B(0x220400000A80040, 0x806080020810010C), B(0xA000200000000080, 0x1040801A0081208), }; #undef B #endif #endif // #ifndef MAGIC_H_INCLUDEDFairy-Stockfish-fairy_sf_11_1/src/main.cpp000066400000000000000000000031701366242550200206310ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include "bitboard.h" #include "position.h" #include "search.h" #include "thread.h" #include "tt.h" #include "uci.h" #include "endgame.h" #include "piece.h" #include "variant.h" #include "syzygy/tbprobe.h" namespace PSQT { void init(const Variant* v); } int main(int argc, char* argv[]) { std::cout << engine_info() << std::endl; pieceMap.init(); variants.init(); UCI::init(Options); PSQT::init(variants.find(Options["UCI_Variant"])->second); Bitboards::init(); Position::init(); Bitbases::init(); Endgames::init(); Threads.set(Options["Threads"]); Search::clear(); // After threads are up UCI::loop(argc, argv); Threads.set(0); variants.clear_all(); pieceMap.clear_all(); return 0; } Fairy-Stockfish-fairy_sf_11_1/src/material.cpp000066400000000000000000000223321366242550200215040ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include // For std::memset #include "material.h" #include "thread.h" using namespace std; namespace { // Polynomial material imbalance parameters constexpr int QuadraticOurs[][PIECE_TYPE_NB] = { // OUR PIECES // pair pawn knight bishop rook queen {1438 }, // Bishop pair { 40, 38 }, // Pawn { 32, 255, -62 }, // Knight OUR PIECES { 0, 104, 4, 0 }, // Bishop { -26, -2, 47, 105, -208 }, // Rook {-189, 24, 117, 133, -134, -6 } // Queen }; constexpr int QuadraticTheirs[][PIECE_TYPE_NB] = { // THEIR PIECES // pair pawn knight bishop rook queen { 0 }, // Bishop pair { 36, 0 }, // Pawn { 9, 63, 0 }, // Knight OUR PIECES { 59, 65, 42, 0 }, // Bishop { 46, 39, 24, -24, 0 }, // Rook { 97, 100, -42, 137, 268, 0 } // Queen }; // Endgame evaluation and scaling functions are accessed directly and not through // the function maps because they correspond to more than one material hash key. Endgame EvaluateKFsPsK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame EvaluateKXK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKBPsK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKQKRPs[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKPsK[] = { Endgame(WHITE), Endgame(BLACK) }; Endgame ScaleKPKP[] = { Endgame(WHITE), Endgame(BLACK) }; // Helper used to detect a given material distribution bool is_KFsPsK(const Position& pos, Color us) { return pos.promotion_piece_types().size() == 1 && pos.promotion_piece_types().find(FERS) != pos.promotion_piece_types().end() && !more_than_one(pos.pieces(~us)) && (pos.count(us) || pos.count(us)) && !(pos.count(us) - pos.count(us) - pos.count(us) - pos.count(us)); } bool is_KXK(const Position& pos, Color us) { return !more_than_one(pos.pieces(~us)) && pos.non_pawn_material(us) >= RookValueMg; } bool is_KBPsK(const Position& pos, Color us) { return pos.non_pawn_material(us) == BishopValueMg && pos.count(us) >= 1; } bool is_KQKRPs(const Position& pos, Color us) { return !pos.count(us) && pos.non_pawn_material(us) == QueenValueMg && pos.count(~us) == 1 && pos.count(~us) >= 1; } /// imbalance() calculates the imbalance by comparing the piece count of each /// piece type for both colors. template int imbalance(const Position& pos, const int pieceCount[][PIECE_TYPE_NB]) { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); int bonus = 0; // Second-degree polynomial material imbalance, by Tord Romstad for (int pt1 = NO_PIECE_TYPE; pt1 <= QUEEN; ++pt1) { if (!pieceCount[Us][pt1] || (pos.extinction_value() == VALUE_MATE && pt1 != KNIGHT)) continue; int v = 0; for (int pt2 = NO_PIECE_TYPE; pt2 <= pt1; ++pt2) v += QuadraticOurs[pt1][pt2] * pieceCount[Us][pt2] * (pos.must_capture() && pt1 == KNIGHT && pt2 == PAWN ? 2 : pos.check_counting() && pt1 <= BISHOP ? 0 : 1) + QuadraticTheirs[pt1][pt2] * pieceCount[Them][pt2]; bonus += pieceCount[Us][pt1] * v; } return bonus * (1 + pos.must_capture()); } } // namespace namespace Material { /// Material::probe() looks up the current position's material configuration in /// the material hash table. It returns a pointer to the Entry if the position /// is found. Otherwise a new Entry is computed and stored there, so we don't /// have to recompute all when the same material configuration occurs again. Entry* probe(const Position& pos) { Key key = pos.material_key(); Entry* e = pos.this_thread()->materialTable[key]; if (e->key == key) return e; std::memset(e, 0, sizeof(Entry)); e->key = key; e->factor[WHITE] = e->factor[BLACK] = (uint8_t)SCALE_FACTOR_NORMAL; Value npm_w = pos.non_pawn_material(WHITE); Value npm_b = pos.non_pawn_material(BLACK); Value npm = clamp(npm_w + npm_b, EndgameLimit, MidgameLimit); // Map total non-pawn material into [PHASE_ENDGAME, PHASE_MIDGAME] if (pos.captures_to_hand()) { Value npm2 = VALUE_ZERO; for (PieceType pt : pos.piece_types()) npm2 += (pos.count_in_hand(WHITE, pt) + pos.count_in_hand(BLACK, pt)) * PieceValue[MG][make_piece(WHITE, pt)]; e->gamePhase = Phase(PHASE_MIDGAME * npm / std::max(int(npm + npm2), 1)); } else e->gamePhase = Phase(((npm - EndgameLimit) * PHASE_MIDGAME) / (MidgameLimit - EndgameLimit)); if (pos.endgame_eval()) { // Let's look if we have a specialized evaluation function for this particular // material configuration. Firstly we look for a fixed configuration one, then // for a generic one if the previous search failed. if ((e->evaluationFunction = Endgames::probe(key)) != nullptr) return e; for (Color c : { WHITE, BLACK }) if (is_KFsPsK(pos, c)) { e->evaluationFunction = &EvaluateKFsPsK[c]; return e; } for (Color c : { WHITE, BLACK }) if (is_KXK(pos, c)) { e->evaluationFunction = &EvaluateKXK[c]; return e; } // OK, we didn't find any special evaluation function for the current material // configuration. Is there a suitable specialized scaling function? const auto* sf = Endgames::probe(key); if (sf) { e->scalingFunction[sf->strongSide] = sf; // Only strong color assigned return e; } // We didn't find any specialized scaling function, so fall back on generic // ones that refer to more than one material distribution. Note that in this // case we don't return after setting the function. for (Color c : { WHITE, BLACK }) { if (is_KBPsK(pos, c)) e->scalingFunction[c] = &ScaleKBPsK[c]; else if (is_KQKRPs(pos, c)) e->scalingFunction[c] = &ScaleKQKRPs[c]; } if (npm_w + npm_b == VALUE_ZERO && pos.pieces(PAWN)) // Only pawns on the board { if (!pos.count(BLACK)) { assert(pos.count(WHITE) >= 2); e->scalingFunction[WHITE] = &ScaleKPsK[WHITE]; } else if (!pos.count(WHITE)) { assert(pos.count(BLACK) >= 2); e->scalingFunction[BLACK] = &ScaleKPsK[BLACK]; } else if (pos.count(WHITE) == 1 && pos.count(BLACK) == 1) { // This is a special case because we set scaling functions // for both colors instead of only one. e->scalingFunction[WHITE] = &ScaleKPKP[WHITE]; e->scalingFunction[BLACK] = &ScaleKPKP[BLACK]; } } // Zero or just one pawn makes it difficult to win, even with a small material // advantage. This catches some trivial draws like KK, KBK and KNK and gives a // drawish scale factor for cases such as KRKBP and KmmKm (except for KBBKN). if (!pos.count(WHITE) && npm_w - npm_b <= BishopValueMg) e->factor[WHITE] = uint8_t(npm_w < RookValueMg ? SCALE_FACTOR_DRAW : npm_b <= BishopValueMg ? 4 : 14); if (!pos.count(BLACK) && npm_b - npm_w <= BishopValueMg) e->factor[BLACK] = uint8_t(npm_b < RookValueMg ? SCALE_FACTOR_DRAW : npm_w <= BishopValueMg ? 4 : 14); } // Evaluate the material imbalance. We use PIECE_TYPE_NONE as a place holder // for the bishop pair "extended piece", which allows us to be more flexible // in defining bishop pair bonuses. const int pieceCount[COLOR_NB][PIECE_TYPE_NB] = { { pos.count(WHITE) > 1, pos.count(WHITE), pos.count(WHITE), pos.count(WHITE) , pos.count(WHITE), pos.count(WHITE) }, { pos.count(BLACK) > 1, pos.count(BLACK), pos.count(BLACK), pos.count(BLACK) , pos.count(BLACK), pos.count(BLACK) } }; e->value = int16_t((imbalance(pos, pieceCount) - imbalance(pos, pieceCount)) / 16); return e; } } // namespace Material Fairy-Stockfish-fairy_sf_11_1/src/material.h000066400000000000000000000056501366242550200211550ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef MATERIAL_H_INCLUDED #define MATERIAL_H_INCLUDED #include "endgame.h" #include "misc.h" #include "position.h" #include "types.h" namespace Material { /// Material::Entry contains various information about a material configuration. /// It contains a material imbalance evaluation, a function pointer to a special /// endgame evaluation function (which in most cases is NULL, meaning that the /// standard evaluation function will be used), and scale factors. /// /// The scale factors are used to scale the evaluation score up or down. For /// instance, in KRB vs KR endgames, the score is scaled down by a factor of 4, /// which will result in scores of absolute value less than one pawn. struct Entry { Score imbalance() const { return make_score(value, value); } Phase game_phase() const { return gamePhase; } bool specialized_eval_exists() const { return evaluationFunction != nullptr; } Value evaluate(const Position& pos) const { return (*evaluationFunction)(pos); } // scale_factor takes a position and a color as input and returns a scale factor // for the given color. We have to provide the position in addition to the color // because the scale factor may also be a function which should be applied to // the position. For instance, in KBP vs K endgames, the scaling function looks // for rook pawns and wrong-colored bishops. ScaleFactor scale_factor(const Position& pos, Color c) const { ScaleFactor sf = scalingFunction[c] ? (*scalingFunction[c])(pos) : SCALE_FACTOR_NONE; return sf != SCALE_FACTOR_NONE ? sf : ScaleFactor(factor[c]); } Key key; const EndgameBase* evaluationFunction; const EndgameBase* scalingFunction[COLOR_NB]; // Could be one for each // side (e.g. KPKP, KBPsK) int16_t value; uint8_t factor[COLOR_NB]; Phase gamePhase; }; typedef HashTable Table; Entry* probe(const Position& pos); } // namespace Material #endif // #ifndef MATERIAL_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/misc.cpp000066400000000000000000000257621366242550200206530ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifdef _WIN32 #if _WIN32_WINNT < 0x0601 #undef _WIN32_WINNT #define _WIN32_WINNT 0x0601 // Force to include needed API prototypes #endif #ifndef NOMINMAX #define NOMINMAX #endif #include // The needed Windows API for processor groups could be missed from old Windows // versions, so instead of calling them directly (forcing the linker to resolve // the calls at compile time), try to load them at runtime. To do this we need // first to define the corresponding function pointers. extern "C" { typedef bool(*fun1_t)(LOGICAL_PROCESSOR_RELATIONSHIP, PSYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX, PDWORD); typedef bool(*fun2_t)(USHORT, PGROUP_AFFINITY); typedef bool(*fun3_t)(HANDLE, CONST GROUP_AFFINITY*, PGROUP_AFFINITY); } #endif #include #include #include #include #include #include "misc.h" #include "thread.h" using namespace std; namespace { /// Version number. If Version is left empty, then compile date in the format /// DD-MM-YY and show in engine_info. const string Version = "11.1"; /// Our fancy logging facility. The trick here is to replace cin.rdbuf() and /// cout.rdbuf() with two Tie objects that tie cin and cout to a file stream. We /// can toggle the logging of std::cout and std:cin at runtime whilst preserving /// usual I/O functionality, all without changing a single line of code! /// Idea from http://groups.google.com/group/comp.lang.c++/msg/1d941c0f26ea0d81 struct Tie: public streambuf { // MSVC requires split streambuf for cin and cout Tie(streambuf* b, streambuf* l) : buf(b), logBuf(l) {} int sync() override { return logBuf->pubsync(), buf->pubsync(); } int overflow(int c) override { return log(buf->sputc((char)c), "<< "); } int underflow() override { return buf->sgetc(); } int uflow() override { return log(buf->sbumpc(), ">> "); } streambuf *buf, *logBuf; int log(int c, const char* prefix) { static int last = '\n'; // Single log file if (last == '\n') logBuf->sputn(prefix, 3); return last = logBuf->sputc((char)c); } }; class Logger { Logger() : in(cin.rdbuf(), file.rdbuf()), out(cout.rdbuf(), file.rdbuf()) {} ~Logger() { start(""); } ofstream file; Tie in, out; public: static void start(const std::string& fname) { static Logger l; if (!fname.empty() && !l.file.is_open()) { l.file.open(fname, ifstream::out); if (!l.file.is_open()) { cerr << "Unable to open debug log file " << fname << endl; exit(EXIT_FAILURE); } cin.rdbuf(&l.in); cout.rdbuf(&l.out); } else if (fname.empty() && l.file.is_open()) { cout.rdbuf(l.out.buf); cin.rdbuf(l.in.buf); l.file.close(); } } }; } // namespace /// engine_info() returns the full name of the current Stockfish version. This /// will be either "Stockfish DD-MM-YY" (where DD-MM-YY is the date when /// the program was compiled) or "Stockfish ", depending on whether /// Version is empty. const string engine_info(bool to_uci) { const string months("Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec"); string month, day, year; stringstream ss, date(__DATE__); // From compiler, format is "Sep 21 2008" ss << "Fairy-Stockfish " << Version << setfill('0'); if (Version.empty()) { date >> month >> day >> year; ss << setw(2) << day << setw(2) << (1 + months.find(month) / 4) << year.substr(2); } #ifdef LARGEBOARDS ss << " LB"; #endif ss << (Is64Bit ? " 64" : "") << (HasPext ? " BMI2" : (HasPopCnt ? " POPCNT" : "")) << (to_uci ? "\nid author ": " by ") << "Fabian Fichter"; return ss.str(); } /// compiler_info() returns a string trying to describe the compiler we use const std::string compiler_info() { #define STRINGIFY2(x) #x #define STRINGIFY(x) STRINGIFY2(x) #define VER_STRING(major, minor, patch) STRINGIFY(major) "." STRINGIFY(minor) "." STRINGIFY(patch) /// Predefined macros hell: /// /// __GNUC__ Compiler is gcc, Clang or Intel on Linux /// __INTEL_COMPILER Compiler is Intel /// _MSC_VER Compiler is MSVC or Intel on Windows /// _WIN32 Building on Windows (any) /// _WIN64 Building on Windows 64 bit std::string compiler = "\nCompiled by "; #ifdef __clang__ compiler += "clang++ "; compiler += VER_STRING(__clang_major__, __clang_minor__, __clang_patchlevel__); #elif __INTEL_COMPILER compiler += "Intel compiler "; compiler += "(version "; compiler += STRINGIFY(__INTEL_COMPILER) " update " STRINGIFY(__INTEL_COMPILER_UPDATE); compiler += ")"; #elif _MSC_VER compiler += "MSVC "; compiler += "(version "; compiler += STRINGIFY(_MSC_FULL_VER) "." STRINGIFY(_MSC_BUILD); compiler += ")"; #elif __GNUC__ compiler += "g++ (GNUC) "; compiler += VER_STRING(__GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__); #else compiler += "Unknown compiler "; compiler += "(unknown version)"; #endif #if defined(__APPLE__) compiler += " on Apple"; #elif defined(__CYGWIN__) compiler += " on Cygwin"; #elif defined(__MINGW64__) compiler += " on MinGW64"; #elif defined(__MINGW32__) compiler += " on MinGW32"; #elif defined(__ANDROID__) compiler += " on Android"; #elif defined(__linux__) compiler += " on Linux"; #elif defined(_WIN64) compiler += " on Microsoft Windows 64-bit"; #elif defined(_WIN32) compiler += " on Microsoft Windows 32-bit"; #else compiler += " on unknown system"; #endif compiler += "\n __VERSION__ macro expands to: "; #ifdef __VERSION__ compiler += __VERSION__; #else compiler += "(undefined macro)"; #endif compiler += "\n"; return compiler; } /// Debug functions used mainly to collect run-time statistics static std::atomic hits[2], means[2]; void dbg_hit_on(bool b) { ++hits[0]; if (b) ++hits[1]; } void dbg_hit_on(bool c, bool b) { if (c) dbg_hit_on(b); } void dbg_mean_of(int v) { ++means[0]; means[1] += v; } void dbg_print() { if (hits[0]) cerr << "Total " << hits[0] << " Hits " << hits[1] << " hit rate (%) " << 100 * hits[1] / hits[0] << endl; if (means[0]) cerr << "Total " << means[0] << " Mean " << (double)means[1] / means[0] << endl; } /// Used to serialize access to std::cout to avoid multiple threads writing at /// the same time. std::ostream& operator<<(std::ostream& os, SyncCout sc) { static std::mutex m; if (sc == IO_LOCK) m.lock(); if (sc == IO_UNLOCK) m.unlock(); return os; } /// Trampoline helper to avoid moving Logger to misc.h void start_logger(const std::string& fname) { Logger::start(fname); } /// prefetch() preloads the given address in L1/L2 cache. This is a non-blocking /// function that doesn't stall the CPU waiting for data to be loaded from memory, /// which can be quite slow. #ifdef NO_PREFETCH void prefetch(void*) {} #else void prefetch(void* addr) { # if defined(__INTEL_COMPILER) // This hack prevents prefetches from being optimized away by // Intel compiler. Both MSVC and gcc seem not be affected by this. __asm__ (""); # endif # if defined(__INTEL_COMPILER) || defined(_MSC_VER) _mm_prefetch((char*)addr, _MM_HINT_T0); # else __builtin_prefetch(addr); # endif } #endif namespace WinProcGroup { #ifndef _WIN32 void bindThisThread(size_t) {} #else /// best_group() retrieves logical processor information using Windows specific /// API and returns the best group id for the thread with index idx. Original /// code from Texel by Peter Österlund. int best_group(size_t idx) { int threads = 0; int nodes = 0; int cores = 0; DWORD returnLength = 0; DWORD byteOffset = 0; // Early exit if the needed API is not available at runtime HMODULE k32 = GetModuleHandle("Kernel32.dll"); auto fun1 = (fun1_t)(void(*)())GetProcAddress(k32, "GetLogicalProcessorInformationEx"); if (!fun1) return -1; // First call to get returnLength. We expect it to fail due to null buffer if (fun1(RelationAll, nullptr, &returnLength)) return -1; // Once we know returnLength, allocate the buffer SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX *buffer, *ptr; ptr = buffer = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)malloc(returnLength); // Second call, now we expect to succeed if (!fun1(RelationAll, buffer, &returnLength)) { free(buffer); return -1; } while (byteOffset < returnLength) { if (ptr->Relationship == RelationNumaNode) nodes++; else if (ptr->Relationship == RelationProcessorCore) { cores++; threads += (ptr->Processor.Flags == LTP_PC_SMT) ? 2 : 1; } assert(ptr->Size); byteOffset += ptr->Size; ptr = (SYSTEM_LOGICAL_PROCESSOR_INFORMATION_EX*)(((char*)ptr) + ptr->Size); } free(buffer); std::vector groups; // Run as many threads as possible on the same node until core limit is // reached, then move on filling the next node. for (int n = 0; n < nodes; n++) for (int i = 0; i < cores / nodes; i++) groups.push_back(n); // In case a core has more than one logical processor (we assume 2) and we // have still threads to allocate, then spread them evenly across available // nodes. for (int t = 0; t < threads - cores; t++) groups.push_back(t % nodes); // If we still have more threads than the total number of logical processors // then return -1 and let the OS to decide what to do. return idx < groups.size() ? groups[idx] : -1; } /// bindThisThread() set the group affinity of the current thread void bindThisThread(size_t idx) { // Use only local variables to be thread-safe int group = best_group(idx); if (group == -1) return; // Early exit if the needed API are not available at runtime HMODULE k32 = GetModuleHandle("Kernel32.dll"); auto fun2 = (fun2_t)(void(*)())GetProcAddress(k32, "GetNumaNodeProcessorMaskEx"); auto fun3 = (fun3_t)(void(*)())GetProcAddress(k32, "SetThreadGroupAffinity"); if (!fun2 || !fun3) return; GROUP_AFFINITY affinity; if (fun2(group, &affinity)) fun3(GetCurrentThread(), &affinity, nullptr); } #endif } // namespace WinProcGroup Fairy-Stockfish-fairy_sf_11_1/src/misc.h000066400000000000000000000066741366242550200203210ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef MISC_H_INCLUDED #define MISC_H_INCLUDED #include #include #include #include #include #include "types.h" const std::string engine_info(bool to_uci = false); const std::string compiler_info(); void prefetch(void* addr); void start_logger(const std::string& fname); void dbg_hit_on(bool b); void dbg_hit_on(bool c, bool b); void dbg_mean_of(int v); void dbg_print(); typedef std::chrono::milliseconds::rep TimePoint; // A value in milliseconds static_assert(sizeof(TimePoint) == sizeof(int64_t), "TimePoint should be 64 bits"); inline TimePoint now() { return std::chrono::duration_cast (std::chrono::steady_clock::now().time_since_epoch()).count(); } template struct HashTable { Entry* operator[](Key key) { return &table[(uint32_t)key & (Size - 1)]; } private: std::vector table = std::vector(Size); // Allocate on the heap }; enum SyncCout { IO_LOCK, IO_UNLOCK }; std::ostream& operator<<(std::ostream&, SyncCout); #define sync_cout std::cout << IO_LOCK #define sync_endl std::endl << IO_UNLOCK /// xorshift64star Pseudo-Random Number Generator /// This class is based on original code written and dedicated /// to the public domain by Sebastiano Vigna (2014). /// It has the following characteristics: /// /// - Outputs 64-bit numbers /// - Passes Dieharder and SmallCrush test batteries /// - Does not require warm-up, no zeroland to escape /// - Internal state is a single 64-bit integer /// - Period is 2^64 - 1 /// - Speed: 1.60 ns/call (Core i7 @3.40GHz) /// /// For further analysis see /// class PRNG { uint64_t s; uint64_t rand64() { s ^= s >> 12, s ^= s << 25, s ^= s >> 27; return s * 2685821657736338717LL; } public: PRNG(uint64_t seed) : s(seed) { assert(seed); } template T rand() { return T(rand64()); } /// Special generator used to fast init magic numbers. /// Output values only have 1/8th of their bits set on average. template T sparse_rand() { return T(rand64() & rand64() & rand64()); } }; /// Under Windows it is not possible for a process to run on more than one /// logical processor group. This usually means to be limited to use max 64 /// cores. To overcome this, some special platform specific API should be /// called to set group affinity for each thread. Original code from Texel by /// Peter Österlund. namespace WinProcGroup { void bindThisThread(size_t idx); } #endif // #ifndef MISC_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/movegen.cpp000066400000000000000000000477741366242550200213670ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include "movegen.h" #include "position.h" namespace { template ExtMove* make_move_and_gating(const Position& pos, ExtMove* moveList, Color us, Square from, Square to) { *moveList++ = make(from, to); // Gating moves if (pos.seirawan_gating() && (pos.gates(us) & from)) for (PieceType pt_gating : pos.piece_types()) if (pos.count_in_hand(us, pt_gating) && (pos.drop_region(us, pt_gating) & from)) *moveList++ = make_gating(from, to, pt_gating, from); if (pos.seirawan_gating() && T == CASTLING && (pos.gates(us) & to)) for (PieceType pt_gating : pos.piece_types()) if (pos.count_in_hand(us, pt_gating) && (pos.drop_region(us, pt_gating) & to)) *moveList++ = make_gating(from, to, pt_gating, to); return moveList; } template ExtMove* make_promotions(const Position& pos, ExtMove* moveList, Square to) { if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS) { for (PieceType pt : pos.promotion_piece_types()) if (!pos.promotion_limit(pt) || pos.promotion_limit(pt) > pos.count(c, pt)) *moveList++ = make(to - D, to, pt); PieceType pt = pos.promoted_piece_type(PAWN); if (pt && !(pos.piece_promotion_on_capture() && pos.empty(to))) *moveList++ = make(to - D, to); } return moveList; } template ExtMove* generate_drops(const Position& pos, ExtMove* moveList, PieceType pt, Bitboard b) { if (pos.count_in_hand(Us, pt)) { // Restrict to valid target b &= pos.drop_region(Us, pt); // Add to move list if (pos.drop_promoted() && pos.promoted_piece_type(pt)) { Bitboard b2 = b; if (Checks) b2 &= pos.check_squares(pos.promoted_piece_type(pt)); while (b2) *moveList++ = make_drop(pop_lsb(&b2), pt, pos.promoted_piece_type(pt)); } if (Checks) b &= pos.check_squares(pt); while (b) *moveList++ = make_drop(pop_lsb(&b), pt, pt); } return moveList; } template ExtMove* generate_pawn_moves(const Position& pos, ExtMove* moveList, Bitboard target) { // Compute some compile time parameters relative to the white side constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Up = pawn_push(Us); constexpr Direction Down = -pawn_push(Us); constexpr Direction UpRight = (Us == WHITE ? NORTH_EAST : SOUTH_WEST); constexpr Direction UpLeft = (Us == WHITE ? NORTH_WEST : SOUTH_EAST); const Square ksq = pos.count(Them) ? pos.square(Them) : SQ_NONE; Bitboard TRank8BB = pos.mandatory_pawn_promotion() ? rank_bb(relative_rank(Us, pos.promotion_rank(), pos.max_rank())) : promotion_zone_bb(Us, pos.promotion_rank(), pos.max_rank()); Bitboard TRank7BB = shift(TRank8BB); // Define squares a pawn can pass during a double step Bitboard TRank3BB = rank_bb(relative_rank(Us, Rank(pos.double_step_rank() + 1), pos.max_rank())); if (pos.first_rank_double_steps()) TRank3BB |= rank_bb(relative_rank(Us, RANK_2, pos.max_rank())); Bitboard emptySquares; Bitboard pawnsOn7 = pos.pieces(Us, PAWN) & TRank7BB; Bitboard pawnsNotOn7 = pos.pieces(Us, PAWN) & (pos.mandatory_pawn_promotion() ? ~TRank7BB : AllSquares); Bitboard enemies = (Type == EVASIONS ? pos.pieces(Them) & target: Type == CAPTURES ? target : pos.pieces(Them)); // Single and double pawn pushes, no promotions if (Type != CAPTURES) { emptySquares = (Type == QUIETS || Type == QUIET_CHECKS ? target : ~pos.pieces() & pos.board_bb(Us, PAWN)); Bitboard b1 = shift(pawnsNotOn7) & emptySquares; Bitboard b2 = pos.double_step_enabled() ? shift(b1 & TRank3BB) & emptySquares : Bitboard(0); if (Type == EVASIONS) // Consider only blocking squares { b1 &= target; b2 &= target; } if (Type == QUIET_CHECKS && pos.count(Them)) { b1 &= pos.attacks_from(ksq, Them); b2 &= pos.attacks_from(ksq, Them); // Add pawn pushes which give discovered check. This is possible only // if the pawn is not on the same file as the enemy king, because we // don't generate captures. Note that a possible discovery check // promotion has been already generated amongst the captures. Bitboard dcCandidateQuiets = pos.blockers_for_king(Them) & pawnsNotOn7; if (dcCandidateQuiets) { Bitboard dc1 = shift(dcCandidateQuiets) & emptySquares & ~file_bb(ksq); Bitboard dc2 = pos.double_step_enabled() ? shift(dc1 & TRank3BB) & emptySquares : Bitboard(0); b1 |= dc1; b2 |= dc2; } } while (b1) { Square to = pop_lsb(&b1); *moveList++ = make_move(to - Up, to); } while (b2) { Square to = pop_lsb(&b2); *moveList++ = make_move(to - Up - Up, to); } } // Promotions and underpromotions if (pawnsOn7) { if (Type == CAPTURES) emptySquares = ~pos.pieces() & pos.board_bb(Us, PAWN); if (Type == EVASIONS) emptySquares &= target; Bitboard b1 = shift(pawnsOn7) & enemies; Bitboard b2 = shift(pawnsOn7) & enemies; Bitboard b3 = shift(pawnsOn7) & emptySquares; while (b1) moveList = make_promotions(pos, moveList, pop_lsb(&b1)); while (b2) moveList = make_promotions(pos, moveList, pop_lsb(&b2)); while (b3) moveList = make_promotions(pos, moveList, pop_lsb(&b3)); } // Sittuyin promotions if (pos.sittuyin_promotion() && (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS)) { Bitboard pawns = pos.pieces(Us, PAWN); // Pawns need to be on diagonals on opponent's half if there is more than one pawn if (pos.count(Us) > 1) pawns &= ( PseudoAttacks[Us][BISHOP][make_square(FILE_A, relative_rank(Us, RANK_1, pos.max_rank()))] | PseudoAttacks[Us][BISHOP][make_square(pos.max_file(), relative_rank(Us, RANK_1, pos.max_rank()))]) & forward_ranks_bb(Us, relative_rank(Us, Rank((pos.max_rank() - 1) / 2), pos.max_rank())); while (pawns) { Square from = pop_lsb(&pawns); for (PieceType pt : pos.promotion_piece_types()) { if (pos.promotion_limit(pt) && pos.promotion_limit(pt) <= pos.count(Us, pt)) continue; Bitboard b = (pos.attacks_from(Us, pt, from) & ~pos.pieces()) | from; if (Type == EVASIONS) b &= target; while (b) { Square to = pop_lsb(&b); if (!(attacks_bb(Us, pt, to, pos.pieces() ^ from) & pos.pieces(Them))) *moveList++ = make(from, to, pt); } } } } // Standard and en-passant captures if (Type == CAPTURES || Type == EVASIONS || Type == NON_EVASIONS) { Bitboard b1 = shift(pawnsNotOn7) & enemies; Bitboard b2 = shift(pawnsNotOn7) & enemies; while (b1) { Square to = pop_lsb(&b1); *moveList++ = make_move(to - UpRight, to); } while (b2) { Square to = pop_lsb(&b2); *moveList++ = make_move(to - UpLeft, to); } if (pos.ep_square() != SQ_NONE) { assert(rank_of(pos.ep_square()) == relative_rank(Them, Rank(pos.double_step_rank() + 1), pos.max_rank())); // An en passant capture can be an evasion only if the checking piece // is the double pushed pawn and so is in the target. Otherwise this // is a discovery check and we are forced to do otherwise. if (Type == EVASIONS && !(target & (pos.ep_square() - Up))) return moveList; b1 = pawnsNotOn7 & pos.attacks_from(pos.ep_square(), Them); assert(b1); while (b1) *moveList++ = make(pop_lsb(&b1), pos.ep_square()); } } return moveList; } template ExtMove* generate_moves(const Position& pos, ExtMove* moveList, Color us, PieceType pt, Bitboard target) { assert(pt != KING && pt != PAWN); const Square* pl = pos.squares(us, pt); for (Square from = *pl; from != SQ_NONE; from = *++pl) { // Avoid generating discovered checks twice if (Checks && (pos.blockers_for_king(~us) & from)) continue; Bitboard b1 = ( (pos.attacks_from(us, pt, from) & pos.pieces()) | (pos.moves_from(us, pt, from) & ~pos.pieces())) & target; PieceType prom_pt = pos.promoted_piece_type(pt); Bitboard b2 = prom_pt && (!pos.promotion_limit(prom_pt) || pos.promotion_limit(prom_pt) > pos.count(us, prom_pt)) ? b1 : Bitboard(0); Bitboard b3 = pos.piece_demotion() && pos.is_promoted(from) ? b1 : Bitboard(0); if (Checks) { b1 &= pos.check_squares(pt); if (b2) b2 &= pos.check_squares(pos.promoted_piece_type(pt)); if (b3) b3 &= pos.check_squares(type_of(pos.unpromoted_piece_on(from))); } // Restrict target squares considering promotion zone if (b2 | b3) { Bitboard promotion_zone = promotion_zone_bb(us, pos.promotion_rank(), pos.max_rank()); if (pos.mandatory_piece_promotion()) b1 &= (promotion_zone & from ? Bitboard(0) : ~promotion_zone) | (pos.piece_promotion_on_capture() ? ~pos.pieces() : Bitboard(0)); // Exclude quiet promotions/demotions if (pos.piece_promotion_on_capture()) { b2 &= pos.pieces(); b3 &= pos.pieces(); } // Consider promotions/demotions into promotion zone if (!(promotion_zone & from)) { b2 &= promotion_zone; b3 &= promotion_zone; } } while (b1) moveList = make_move_and_gating(pos, moveList, us, from, pop_lsb(&b1)); // Shogi-style piece promotions while (b2) *moveList++ = make(from, pop_lsb(&b2)); // Piece demotions while (b3) *moveList++ = make(from, pop_lsb(&b3)); } return moveList; } template ExtMove* generate_all(const Position& pos, ExtMove* moveList, Bitboard target) { constexpr CastlingRights OO = Us & KING_SIDE; constexpr CastlingRights OOO = Us & QUEEN_SIDE; constexpr bool Checks = Type == QUIET_CHECKS; // Reduce template instantations moveList = generate_pawn_moves(pos, moveList, target); for (PieceType pt : pos.piece_types()) if (pt != PAWN && pt != KING) moveList = generate_moves(pos, moveList, Us, pt, target); // generate drops if (pos.piece_drops() && Type != CAPTURES && pos.count_in_hand(Us, ALL_PIECES)) for (PieceType pt : pos.piece_types()) moveList = generate_drops(pos, moveList, pt, target & ~pos.pieces(~Us)); if (Type != QUIET_CHECKS && Type != EVASIONS && pos.count(Us)) { Square ksq = pos.square(Us); Bitboard b = ( (pos.attacks_from(Us, KING, ksq) & pos.pieces()) | (pos.moves_from(Us, KING, ksq) & ~pos.pieces())) & target; while (b) moveList = make_move_and_gating(pos, moveList, Us, ksq, pop_lsb(&b)); // Passing move by king if (pos.king_pass()) *moveList++ = make(ksq, ksq); if (Type != CAPTURES && pos.can_castle(CastlingRights(OO | OOO))) { if (!pos.castling_impeded(OO) && pos.can_castle(OO)) moveList = make_move_and_gating(pos, moveList, Us, ksq, pos.castling_rook_square(OO)); if (!pos.castling_impeded(OOO) && pos.can_castle(OOO)) moveList = make_move_and_gating(pos, moveList, Us, ksq, pos.castling_rook_square(OOO)); } } // Castling with non-king piece if (!pos.count(Us) && Type != CAPTURES && pos.can_castle(CastlingRights(OO | OOO))) { Square from = make_square(FILE_E, pos.castling_rank(Us)); if (!pos.castling_impeded(OO) && pos.can_castle(OO)) moveList = make_move_and_gating(pos, moveList, Us, from, pos.castling_rook_square(OO)); if (!pos.castling_impeded(OOO) && pos.can_castle(OOO)) moveList = make_move_and_gating(pos, moveList, Us, from, pos.castling_rook_square(OOO)); } // Special moves if (pos.cambodian_moves() && pos.gates(Us)) { if (Type != CAPTURES && Type != EVASIONS && (pos.pieces(Us, KING) & pos.gates(Us))) { Square from = pos.square(Us); Bitboard b = PseudoAttacks[WHITE][KNIGHT][from] & rank_bb(rank_of(from + (Us == WHITE ? NORTH : SOUTH))) & target & ~pos.pieces(); while (b) moveList = make_move_and_gating(pos, moveList, Us, from, pop_lsb(&b)); } Bitboard b = pos.pieces(Us, FERS) & pos.gates(Us); while (b) { Square from = pop_lsb(&b); Square to = from + 2 * (Us == WHITE ? NORTH : SOUTH); if (is_ok(to) && (target & to)) moveList = make_move_and_gating(pos, moveList, Us, from, to); } } return moveList; } } // namespace /// Generates all pseudo-legal captures and queen promotions /// Generates all pseudo-legal non-captures and underpromotions /// Generates all pseudo-legal captures and non-captures /// /// Returns a pointer to the end of the move list. template ExtMove* generate(const Position& pos, ExtMove* moveList) { static_assert(Type == CAPTURES || Type == QUIETS || Type == NON_EVASIONS, "Unsupported type in generate()"); assert(!pos.checkers()); Color us = pos.side_to_move(); Bitboard target = Type == CAPTURES ? pos.pieces(~us) : Type == QUIETS ? ~pos.pieces() : Type == NON_EVASIONS ? ~pos.pieces(us) : Bitboard(0); target &= pos.board_bb(); return us == WHITE ? generate_all(pos, moveList, target) : generate_all(pos, moveList, target); } // Explicit template instantiations template ExtMove* generate(const Position&, ExtMove*); template ExtMove* generate(const Position&, ExtMove*); template ExtMove* generate(const Position&, ExtMove*); /// generate generates all pseudo-legal non-captures and knight /// underpromotions that give check. Returns a pointer to the end of the move list. template<> ExtMove* generate(const Position& pos, ExtMove* moveList) { assert(!pos.checkers()); Color us = pos.side_to_move(); Bitboard dc = pos.blockers_for_king(~us) & pos.pieces(us); while (dc) { Square from = pop_lsb(&dc); PieceType pt = type_of(pos.piece_on(from)); if (pt == PAWN) continue; // Will be generated together with direct checks Bitboard b = pos.moves_from(us, pt, from) & ~pos.pieces(); if (pt == KING && pos.king_type() == KING) b &= ~PseudoAttacks[~us][QUEEN][pos.square(~us)]; while (b) moveList = make_move_and_gating(pos, moveList, us, from, pop_lsb(&b)); } return us == WHITE ? generate_all(pos, moveList, ~pos.pieces() & pos.board_bb()) : generate_all(pos, moveList, ~pos.pieces() & pos.board_bb()); } /// generate generates all pseudo-legal check evasions when the side /// to move is in check. Returns a pointer to the end of the move list. template<> ExtMove* generate(const Position& pos, ExtMove* moveList) { assert(pos.checkers()); Color us = pos.side_to_move(); Square ksq = pos.square(us); Bitboard sliderAttacks = 0; Bitboard sliders = pos.checkers(); // Passing move by king in bikjang if (pos.bikjang() && pos.king_pass()) *moveList++ = make(ksq, ksq); // Consider all evasion moves for special pieces if (sliders & (pos.pieces(CANNON, BANNER) | pos.pieces(HORSE, ELEPHANT) | pos.pieces(JANGGI_CANNON, JANGGI_ELEPHANT))) { Bitboard target = pos.board_bb() & ~pos.pieces(us); Bitboard b = ( (pos.attacks_from(us, KING, ksq) & pos.pieces()) | (pos.moves_from(us, KING, ksq) & ~pos.pieces())) & target; while (b) moveList = make_move_and_gating(pos, moveList, us, ksq, pop_lsb(&b)); return us == WHITE ? generate_all(pos, moveList, target) : generate_all(pos, moveList, target); } // Find all the squares attacked by slider checkers. We will remove them from // the king evasions in order to skip known illegal moves, which avoids any // useless legality checks later on. while (sliders) { Square checksq = pop_lsb(&sliders); sliderAttacks |= attacks_bb(~us, type_of(pos.piece_on(checksq)), checksq, pos.pieces() ^ ksq); } // Generate evasions for king, capture and non capture moves Bitboard b = ( (pos.attacks_from(us, KING, ksq) & pos.pieces()) | (pos.moves_from(us, KING, ksq) & ~pos.pieces())) & ~pos.pieces(us) & ~sliderAttacks; while (b) moveList = make_move_and_gating(pos, moveList, us, ksq, pop_lsb(&b)); if (more_than_one(pos.checkers())) return moveList; // Double check, only a king move can save the day // Generate blocking evasions or captures of the checking piece Square checksq = lsb(pos.checkers()); Bitboard target = between_bb(checksq, ksq) | checksq; // Leaper attacks can not be blocked if (LeaperAttacks[~us][type_of(pos.piece_on(checksq))][checksq] & ksq) target = SquareBB[checksq]; return us == WHITE ? generate_all(pos, moveList, target) : generate_all(pos, moveList, target); } /// generate generates all the legal moves in the given position template<> ExtMove* generate(const Position& pos, ExtMove* moveList) { if (pos.is_immediate_game_end()) return moveList; ExtMove* cur = moveList; moveList = pos.checkers() ? generate(pos, moveList) : generate(pos, moveList); while (cur != moveList) if (!pos.legal(*cur)) *cur = (--moveList)->move; else ++cur; return moveList; } Fairy-Stockfish-fairy_sf_11_1/src/movegen.h000066400000000000000000000041621366242550200210140ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef MOVEGEN_H_INCLUDED #define MOVEGEN_H_INCLUDED #include #include "types.h" class Position; enum GenType { CAPTURES, QUIETS, QUIET_CHECKS, EVASIONS, NON_EVASIONS, LEGAL }; struct ExtMove { Move move; int value; operator Move() const { return move; } void operator=(Move m) { move = m; } // Inhibit unwanted implicit conversions to Move // with an ambiguity that yields to a compile error. operator float() const = delete; }; inline bool operator<(const ExtMove& f, const ExtMove& s) { return f.value < s.value; } template ExtMove* generate(const Position& pos, ExtMove* moveList); /// The MoveList struct is a simple wrapper around generate(). It sometimes comes /// in handy to use this class instead of the low level generate() function. template struct MoveList { explicit MoveList(const Position& pos) : last(generate(pos, moveList)) {} const ExtMove* begin() const { return moveList; } const ExtMove* end() const { return last; } size_t size() const { return last - moveList; } bool contains(Move move) const { return std::find(begin(), end(), move) != end(); } private: ExtMove moveList[MAX_MOVES], *last; }; #endif // #ifndef MOVEGEN_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/movepick.cpp000066400000000000000000000222561366242550200215300ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include "movepick.h" int history_slot(Piece pc) { return pc == NO_PIECE ? 0 : (type_of(pc) == KING ? PIECE_SLOTS - 1 : type_of(pc) % (PIECE_SLOTS - 1)) + color_of(pc) * PIECE_SLOTS; } namespace { enum Stages { MAIN_TT, CAPTURE_INIT, GOOD_CAPTURE, REFUTATION, QUIET_INIT, QUIET, BAD_CAPTURE, EVASION_TT, EVASION_INIT, EVASION, PROBCUT_TT, PROBCUT_INIT, PROBCUT, QSEARCH_TT, QCAPTURE_INIT, QCAPTURE, QCHECK_INIT, QCHECK }; // partial_insertion_sort() sorts moves in descending order up to and including // a given limit. The order of moves smaller than the limit is left unspecified. void partial_insertion_sort(ExtMove* begin, ExtMove* end, int limit) { for (ExtMove *sortedEnd = begin, *p = begin + 1; p < end; ++p) if (p->value >= limit) { ExtMove tmp = *p, *q; *p = *++sortedEnd; for (q = sortedEnd; q != begin && *(q - 1) < tmp; --q) *q = *(q - 1); *q = tmp; } } } // namespace /// Constructors of the MovePicker class. As arguments we pass information /// to help it to return the (presumably) good moves first, to decide which /// moves to return (in the quiescence search, for instance, we only want to /// search captures, promotions, and some checks) and how important good move /// ordering is at the current node. /// MovePicker constructor for the main search MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, const CapturePieceToHistory* cph, const PieceToHistory** ch, Move cm, Move* killers) : pos(p), mainHistory(mh), captureHistory(cph), continuationHistory(ch), refutations{{killers[0], 0}, {killers[1], 0}, {cm, 0}}, depth(d) { assert(d > 0); stage = pos.checkers() ? EVASION_TT : MAIN_TT; ttMove = ttm && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE; stage += (ttMove == MOVE_NONE); } /// MovePicker constructor for quiescence search MovePicker::MovePicker(const Position& p, Move ttm, Depth d, const ButterflyHistory* mh, const CapturePieceToHistory* cph, const PieceToHistory** ch, Square rs) : pos(p), mainHistory(mh), captureHistory(cph), continuationHistory(ch), recaptureSquare(rs), depth(d) { assert(d <= 0); stage = pos.checkers() ? EVASION_TT : QSEARCH_TT; ttMove = ttm && (depth > DEPTH_QS_RECAPTURES || to_sq(ttm) == recaptureSquare) && pos.pseudo_legal(ttm) ? ttm : MOVE_NONE; stage += (ttMove == MOVE_NONE); } /// MovePicker constructor for ProbCut: we generate captures with SEE greater /// than or equal to the given threshold. MovePicker::MovePicker(const Position& p, Move ttm, Value th, const CapturePieceToHistory* cph) : pos(p), captureHistory(cph), threshold(th) { assert(!pos.checkers()); stage = PROBCUT_TT; ttMove = ttm && pos.capture(ttm) && pos.pseudo_legal(ttm) && pos.see_ge(ttm, threshold) ? ttm : MOVE_NONE; stage += (ttMove == MOVE_NONE); } /// MovePicker::score() assigns a numerical value to each move in a list, used /// for sorting. Captures are ordered by Most Valuable Victim (MVV), preferring /// captures with a good history. Quiets moves are ordered using the histories. template void MovePicker::score() { static_assert(Type == CAPTURES || Type == QUIETS || Type == EVASIONS, "Wrong type"); for (auto& m : *this) if (Type == CAPTURES) m.value = int(PieceValue[MG][pos.piece_on(to_sq(m))]) * 6 + (*captureHistory)[pos.moved_piece(m)][to_sq(m)][type_of(pos.piece_on(to_sq(m)))]; else if (Type == QUIETS) m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] + 2 * (*continuationHistory[0])[history_slot(pos.moved_piece(m))][to_sq(m)] + 2 * (*continuationHistory[1])[history_slot(pos.moved_piece(m))][to_sq(m)] + 2 * (*continuationHistory[3])[history_slot(pos.moved_piece(m))][to_sq(m)] + (*continuationHistory[5])[history_slot(pos.moved_piece(m))][to_sq(m)]; else // Type == EVASIONS { if (pos.capture(m)) m.value = PieceValue[MG][pos.piece_on(to_sq(m))] - Value(type_of(pos.moved_piece(m))); else m.value = (*mainHistory)[pos.side_to_move()][from_to(m)] + (*continuationHistory[0])[history_slot(pos.moved_piece(m))][to_sq(m)] - (1 << 28); } } /// MovePicker::select() returns the next move satisfying a predicate function. /// It never returns the TT move. template Move MovePicker::select(Pred filter) { while (cur < endMoves) { if (T == Best) std::swap(*cur, *std::max_element(cur, endMoves)); if (*cur != ttMove && filter()) return *cur++; cur++; } return MOVE_NONE; } /// MovePicker::next_move() is the most important method of the MovePicker class. It /// returns a new pseudo legal move every time it is called until there are no more /// moves left, picking the move with the highest score from a list of generated moves. Move MovePicker::next_move(bool skipQuiets) { top: switch (stage) { case MAIN_TT: case EVASION_TT: case QSEARCH_TT: case PROBCUT_TT: ++stage; assert(pos.legal(ttMove) == MoveList(pos).contains(ttMove)); return ttMove; case CAPTURE_INIT: case PROBCUT_INIT: case QCAPTURE_INIT: cur = endBadCaptures = moves; endMoves = generate(pos, cur); score(); ++stage; goto top; case GOOD_CAPTURE: if (select([&](){ return pos.see_ge(*cur, Value(-55 * cur->value / 1024 - 500 * (pos.captures_to_hand() && pos.gives_check(*cur)))) || pos.must_capture() ? // Move losing capture to endBadCaptures to be tried later true : (*endBadCaptures++ = *cur, false); })) return *(cur - 1); // Prepare the pointers to loop over the refutations array cur = std::begin(refutations); endMoves = std::end(refutations); // If the countermove is the same as a killer, skip it if ( refutations[0].move == refutations[2].move || refutations[1].move == refutations[2].move) --endMoves; ++stage; /* fallthrough */ case REFUTATION: if (select([&](){ return *cur != MOVE_NONE && !pos.capture(*cur) && pos.pseudo_legal(*cur); })) return *(cur - 1); ++stage; /* fallthrough */ case QUIET_INIT: if (!skipQuiets) { cur = endBadCaptures; endMoves = generate(pos, cur); score(); partial_insertion_sort(cur, endMoves, -3000 * depth); } ++stage; /* fallthrough */ case QUIET: if ( !skipQuiets && select([&](){return *cur != refutations[0].move && *cur != refutations[1].move && *cur != refutations[2].move;})) return *(cur - 1); // Prepare the pointers to loop over the bad captures cur = moves; endMoves = endBadCaptures; ++stage; /* fallthrough */ case BAD_CAPTURE: return select([](){ return true; }); case EVASION_INIT: cur = moves; endMoves = generate(pos, cur); score(); ++stage; /* fallthrough */ case EVASION: return select([](){ return true; }); case PROBCUT: return select([&](){ return pos.see_ge(*cur, threshold); }); case QCAPTURE: if (select([&](){ return depth > DEPTH_QS_RECAPTURES || to_sq(*cur) == recaptureSquare; })) return *(cur - 1); // If we did not find any move and we do not try checks, we have finished if (depth != DEPTH_QS_CHECKS) return MOVE_NONE; ++stage; /* fallthrough */ case QCHECK_INIT: cur = moves; endMoves = generate(pos, cur); ++stage; /* fallthrough */ case QCHECK: return select([](){ return true; }); } assert(false); return MOVE_NONE; // Silence warning } Fairy-Stockfish-fairy_sf_11_1/src/movepick.h000066400000000000000000000136261366242550200211760ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef MOVEPICK_H_INCLUDED #define MOVEPICK_H_INCLUDED #include #include #include #include "movegen.h" #include "position.h" #include "types.h" /// StatsEntry stores the stat table value. It is usually a number but could /// be a move or even a nested history. We use a class instead of naked value /// to directly call history update operator<<() on the entry so to use stats /// tables at caller sites as simple multi-dim arrays. template class StatsEntry { T entry; public: void operator=(const T& v) { entry = v; } T* operator&() { return &entry; } T* operator->() { return &entry; } operator const T&() const { return entry; } void operator<<(int bonus) { assert(abs(bonus) <= D); // Ensure range is [-D, D] static_assert(D <= std::numeric_limits::max(), "D overflows T"); entry += bonus - entry * abs(bonus) / D; assert(abs(entry) <= D); } }; /// Stats is a generic N-dimensional array used to store various statistics. /// The first template parameter T is the base type of the array, the second /// template parameter D limits the range of updates in [-D, D] when we update /// values with the << operator, while the last parameters (Size and Sizes) /// encode the dimensions of the array. template struct Stats : public std::array, Size> { typedef Stats stats; void fill(const T& v) { // For standard-layout 'this' points to first struct member assert(std::is_standard_layout::value); typedef StatsEntry entry; entry* p = reinterpret_cast(this); std::fill(p, p + sizeof(*this) / sizeof(entry), v); } }; template struct Stats : public std::array, Size> {}; /// In stats table, D=0 means that the template parameter is not used enum StatsParams { NOT_USED = 0, PIECE_SLOTS = 8 }; enum StatsType { NoCaptures, Captures }; /// ButterflyHistory records how often quiet moves have been successful or /// unsuccessful during the current search, and is used for reduction and move /// ordering decisions. It uses 2 tables (one for each color) indexed by /// the move's from and to squares, see www.chessprogramming.org/Butterfly_Boards typedef Stats ButterflyHistory; /// CounterMoveHistory stores counter moves indexed by [piece][to] of the previous /// move, see www.chessprogramming.org/Countermove_Heuristic typedef Stats CounterMoveHistory; /// CapturePieceToHistory is addressed by a move's [piece][to][captured piece type] typedef Stats CapturePieceToHistory; /// PieceToHistory is like ButterflyHistory but is addressed by a move's [piece][to] typedef Stats PieceToHistory; /// ContinuationHistory is the combined history of a given pair of moves, usually /// the current one given a previous one. The nested history table is based on /// PieceToHistory instead of ButterflyBoards. typedef Stats ContinuationHistory; int history_slot(Piece pc); /// MovePicker class is used to pick one pseudo legal move at a time from the /// current position. The most important method is next_move(), which returns a /// new pseudo legal move each time it is called, until there are no moves left, /// when MOVE_NONE is returned. In order to improve the efficiency of the alpha /// beta algorithm, MovePicker attempts to return the moves which are most likely /// to get a cut-off first. class MovePicker { enum PickType { Next, Best }; public: MovePicker(const MovePicker&) = delete; MovePicker& operator=(const MovePicker&) = delete; MovePicker(const Position&, Move, Value, const CapturePieceToHistory*); MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, const PieceToHistory**, Square); MovePicker(const Position&, Move, Depth, const ButterflyHistory*, const CapturePieceToHistory*, const PieceToHistory**, Move, Move*); Move next_move(bool skipQuiets = false); private: template Move select(Pred); template void score(); ExtMove* begin() { return cur; } ExtMove* end() { return endMoves; } const Position& pos; const ButterflyHistory* mainHistory; const CapturePieceToHistory* captureHistory; const PieceToHistory** continuationHistory; Move ttMove; ExtMove refutations[3], *cur, *endMoves, *endBadCaptures; int stage; Square recaptureSquare; Value threshold; Depth depth; ExtMove moves[MAX_MOVES]; }; #endif // #ifndef MOVEPICK_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/parser.cpp000066400000000000000000000361671366242550200212150ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #include #include #include "parser.h" #include "piece.h" #include "types.h" namespace { template bool set(const std::string& value, T& target) { std::stringstream ss(value); ss >> target; return !ss.fail(); } template <> bool set(const std::string& value, Rank& target) { std::stringstream ss(value); int i; ss >> i; target = Rank(i - 1); return !ss.fail() && target >= RANK_1 && target <= RANK_MAX; } template <> bool set(const std::string& value, File& target) { std::stringstream ss(value); if (isdigit(ss.peek())) { int i; ss >> i; target = File(i - 1); } else { char c; ss >> c; target = File(c - 'a'); } return !ss.fail() && target >= FILE_A && target <= FILE_MAX; } template <> bool set(const std::string& value, std::string& target) { target = value; return true; } template <> bool set(const std::string& value, bool& target) { target = value == "true"; return value == "true" || value == "false"; } template <> bool set(const std::string& value, Value& target) { target = value == "win" ? VALUE_MATE : value == "loss" ? -VALUE_MATE : value == "draw" ? VALUE_DRAW : VALUE_NONE; return value == "win" || value == "loss" || value == "draw" || value == "none"; } template <> bool set(const std::string& value, MaterialCounting& target) { target = value == "janggi" ? JANGGI_MATERIAL : value == "unweighted" ? UNWEIGHTED_MATERIAL : NO_MATERIAL_COUNTING; return value == "janggi" || value == "unweighted" || value == "none"; } template <> bool set(const std::string& value, CountingRule& target) { target = value == "makruk" ? MAKRUK_COUNTING : value == "asean" ? ASEAN_COUNTING : NO_COUNTING; return value == "makruk" || value == "asean" || value == "none"; } template <> bool set(const std::string& value, Bitboard& target) { char file; int rank; std::stringstream ss(value); target = 0; while (!ss.eof() && ss >> file && ss >> rank) target |= file == '*' ? rank_bb(Rank(rank - 1)) : square_bb(make_square(File(tolower(file) - 'a'), Rank(rank - 1))); return !ss.fail(); } } // namespace template template void VariantParser::parse_attribute(const std::string& key, T& target) { const auto& it = config.find(key); if (it != config.end()) { bool valid = set(it->second, target); if (DoCheck && !valid) { std::string typeName = std::is_same() ? "int" : std::is_same() ? "Rank" : std::is_same() ? "File" : std::is_same() ? "bool" : std::is_same() ? "Value" : std::is_same() ? "MaterialCounting" : std::is_same() ? "CountingRule" : std::is_same() ? "Bitboard" : typeid(T).name(); std::cerr << key << " - Invalid value " << it->second << " for type " << typeName << std::endl; } } } template void VariantParser::parse_attribute(const std::string& key, PieceType& target, std::string pieceToChar) { const auto& it = config.find(key); if (it != config.end()) { char token; size_t idx; std::stringstream ss(it->second); if (ss >> token && (idx = pieceToChar.find(toupper(token))) != std::string::npos) target = PieceType(idx); else if (DoCheck) std::cerr << key << " - Invalid piece type: " << token << std::endl; } } template Variant* VariantParser::parse() { Variant* v = new Variant(); v->reset_pieces(); v->promotionPieceTypes = {}; return parse(v); } template Variant* VariantParser::parse(Variant* v) { // piece types for (const auto& pieceInfo : pieceMap) { // piece char const auto& keyValue = config.find(pieceInfo.second->name); if (keyValue != config.end() && !keyValue->second.empty()) { if (isalpha(keyValue->second.at(0))) v->add_piece(pieceInfo.first, keyValue->second.at(0)); else { if (DoCheck && keyValue->second.at(0) != '-') std::cerr << pieceInfo.second->name << " - Invalid letter: " << keyValue->second.at(0) << std::endl; v->remove_piece(pieceInfo.first); } } // mobility region std::string capitalizedPiece = pieceInfo.second->name; capitalizedPiece[0] = toupper(capitalizedPiece[0]); for (Color c : {WHITE, BLACK}) { std::string color = c == WHITE ? "White" : "Black"; parse_attribute("mobilityRegion" + color + capitalizedPiece, v->mobilityRegion[c][pieceInfo.first]); } } parse_attribute("variantTemplate", v->variantTemplate); parse_attribute("pieceToCharTable", v->pieceToCharTable); parse_attribute("pocketSize", v->pocketSize); parse_attribute("maxRank", v->maxRank); parse_attribute("maxFile", v->maxFile); parse_attribute("chess960", v->chess960); parse_attribute("twoBoards", v->twoBoards); parse_attribute("startFen", v->startFen); parse_attribute("promotionRank", v->promotionRank); // promotion piece types const auto& it_prom = config.find("promotionPieceTypes"); if (it_prom != config.end()) { v->promotionPieceTypes = {}; char token; size_t idx = 0; std::stringstream ss(it_prom->second); while (ss >> token && ((idx = v->pieceToChar.find(toupper(token))) != std::string::npos)) v->promotionPieceTypes.insert(PieceType(idx)); if (DoCheck && idx == std::string::npos && token != '-') std::cerr << "promotionPieceTypes - Invalid piece type: " << token << std::endl; } parse_attribute("sittuyinPromotion", v->sittuyinPromotion); // promotion limit const auto& it_prom_limit = config.find("promotionLimit"); if (it_prom_limit != config.end()) { char token; size_t idx = 0; std::stringstream ss(it_prom_limit->second); while (!ss.eof() && ss >> token && (idx = v->pieceToChar.find(toupper(token))) != std::string::npos && ss >> token && ss >> v->promotionLimit[idx]) {} if (DoCheck && idx == std::string::npos) std::cerr << "promotionLimit - Invalid piece type: " << token << std::endl; else if (DoCheck && !ss.eof()) std::cerr << "promotionLimit - Invalid piece count for type: " << v->pieceToChar[idx] << std::endl; } // promoted piece types const auto& it_prom_pt = config.find("promotedPieceType"); if (it_prom_pt != config.end()) { char token; size_t idx = 0, idx2 = 0; std::stringstream ss(it_prom_pt->second); while ( ss >> token && (idx = v->pieceToChar.find(toupper(token))) != std::string::npos && ss >> token && ss >> token && (idx2 = (token == '-' ? 0 : v->pieceToChar.find(toupper(token)))) != std::string::npos) v->promotedPieceType[idx] = PieceType(idx2); if (DoCheck && (idx == std::string::npos || idx2 == std::string::npos)) std::cerr << "promotedPieceType - Invalid piece type: " << token << std::endl; } parse_attribute("piecePromotionOnCapture", v->piecePromotionOnCapture); parse_attribute("mandatoryPawnPromotion", v->mandatoryPawnPromotion); parse_attribute("mandatoryPiecePromotion", v->mandatoryPiecePromotion); parse_attribute("pieceDemotion", v->pieceDemotion); parse_attribute("endgameEval", v->endgameEval); parse_attribute("doubleStep", v->doubleStep); parse_attribute("doubleStepRank", v->doubleStepRank); parse_attribute("firstRankDoubleSteps", v->firstRankDoubleSteps); parse_attribute("castling", v->castling); parse_attribute("castlingDroppedPiece", v->castlingDroppedPiece); parse_attribute("castlingKingsideFile", v->castlingKingsideFile); parse_attribute("castlingQueensideFile", v->castlingQueensideFile); parse_attribute("castlingRank", v->castlingRank); parse_attribute("castlingRookPiece", v->castlingRookPiece, v->pieceToChar); parse_attribute("kingType", v->kingType, v->pieceToChar); parse_attribute("checking", v->checking); parse_attribute("dropChecks", v->dropChecks); parse_attribute("mustCapture", v->mustCapture); parse_attribute("mustDrop", v->mustDrop); parse_attribute("mustDropType", v->mustDropType, v->pieceToChar); parse_attribute("pieceDrops", v->pieceDrops); parse_attribute("dropLoop", v->dropLoop); parse_attribute("capturesToHand", v->capturesToHand); parse_attribute("firstRankPawnDrops", v->firstRankPawnDrops); parse_attribute("promotionZonePawnDrops", v->promotionZonePawnDrops); parse_attribute("dropOnTop", v->dropOnTop); parse_attribute("whiteDropRegion", v->whiteDropRegion); parse_attribute("blackDropRegion", v->blackDropRegion); parse_attribute("sittuyinRookDrop", v->sittuyinRookDrop); parse_attribute("dropOppositeColoredBishop", v->dropOppositeColoredBishop); parse_attribute("dropPromoted", v->dropPromoted); parse_attribute("shogiDoubledPawn", v->shogiDoubledPawn); parse_attribute("immobilityIllegal", v->immobilityIllegal); parse_attribute("gating", v->gating); parse_attribute("seirawanGating", v->seirawanGating); parse_attribute("cambodianMoves", v->cambodianMoves); parse_attribute("diagonalLines", v->diagonalLines); parse_attribute("kingPass", v->kingPass); parse_attribute("kingPassOnStalemate", v->kingPassOnStalemate); parse_attribute("makpongRule", v->makpongRule); parse_attribute("flyingGeneral", v->flyingGeneral); parse_attribute("soldierPromotionRank", v->soldierPromotionRank); // game end parse_attribute("nMoveRule", v->nMoveRule); parse_attribute("nFoldRule", v->nFoldRule); parse_attribute("nFoldValue", v->nFoldValue); parse_attribute("nFoldValueAbsolute", v->nFoldValueAbsolute); parse_attribute("perpetualCheckIllegal", v->perpetualCheckIllegal); parse_attribute("stalemateValue", v->stalemateValue); parse_attribute("checkmateValue", v->checkmateValue); parse_attribute("shogiPawnDropMateIllegal", v->shogiPawnDropMateIllegal); parse_attribute("shatarMateRule", v->shatarMateRule); parse_attribute("bikjangRule", v->bikjangRule); parse_attribute("extinctionValue", v->extinctionValue); parse_attribute("extinctionClaim", v->extinctionClaim); // extinction piece types const auto& it_ext = config.find("extinctionPieceTypes"); if (it_ext != config.end()) { v->extinctionPieceTypes = {}; char token; size_t idx = 0; std::stringstream ss(it_ext->second); while (ss >> token && (idx = token == '*' ? size_t(ALL_PIECES) : v->pieceToChar.find(toupper(token))) != std::string::npos) v->extinctionPieceTypes.insert(PieceType(idx)); if (DoCheck && idx == std::string::npos) std::cerr << "extinctionPieceTypes - Invalid piece type: " << token << std::endl; } parse_attribute("extinctionPieceCount", v->extinctionPieceCount); parse_attribute("extinctionOpponentPieceCount", v->extinctionOpponentPieceCount); parse_attribute("flagPiece", v->flagPiece, v->pieceToChar); parse_attribute("whiteFlag", v->whiteFlag); parse_attribute("blackFlag", v->blackFlag); parse_attribute("flagMove", v->flagMove); parse_attribute("checkCounting", v->checkCounting); parse_attribute("connectN", v->connectN); parse_attribute("materialCounting", v->materialCounting); parse_attribute("countingRule", v->countingRule); // Report invalid options if (DoCheck) { const std::set& parsedKeys = config.get_comsumed_keys(); for (const auto& it : config) if (parsedKeys.find(it.first) == parsedKeys.end()) std::cerr << "Invalid option: " << it.first << std::endl; } // Check consistency if (DoCheck) { // startFen std::string fenBoard = v->startFen.substr(0, v->startFen.find(' ')); std::stringstream ss(fenBoard); char token; ss >> std::noskipws; while (ss >> token) { if (token == '+') { ss >> token; size_t idx = v->pieceToChar.find(toupper(token)); if (idx == std::string::npos || !v->promotedPieceType[idx]) std::cerr << "startFen - Invalid piece type: +" << token << std::endl; } else if (isalpha(token) && v->pieceToChar.find(toupper(token)) == std::string::npos) std::cerr << "startFen - Invalid piece type: " << token << std::endl; } // pieceToCharTable if (v->pieceToCharTable != "-") { ss = std::stringstream(v->pieceToCharTable); while (ss >> token) if (isalpha(token) && v->pieceToChar.find(toupper(token)) == std::string::npos) std::cerr << "pieceToCharTable - Invalid piece type: " << token << std::endl; for (PieceType pt : v->pieceTypes) { char ptl = tolower(v->pieceToChar[pt]); if (v->pieceToCharTable.find(ptl) == std::string::npos && fenBoard.find(ptl) != std::string::npos) std::cerr << "pieceToCharTable - Missing piece type: " << ptl << std::endl; char ptu = toupper(v->pieceToChar[pt]); if (v->pieceToCharTable.find(ptu) == std::string::npos && fenBoard.find(ptu) != std::string::npos) std::cerr << "pieceToCharTable - Missing piece type: " << ptu << std::endl; } } } return v; } template Variant* VariantParser::parse(); template Variant* VariantParser::parse(); template Variant* VariantParser::parse(Variant* v); template Variant* VariantParser::parse(Variant* v); Fairy-Stockfish-fairy_sf_11_1/src/parser.h000066400000000000000000000033431366242550200206500ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #ifndef PARSER_H_INCLUDED #define PARSER_H_INCLUDED #include #include "variant.h" class Config : public std::map { public: Config::iterator find (const std::string& s) { constexpr bool PrintOptions = false; // print config options? if (PrintOptions) std::cout << s << std::endl; consumedKeys.insert(s); return std::map::find(s); } const std::set& get_comsumed_keys() { return consumedKeys; } private: std::set consumedKeys = {}; }; template class VariantParser { public: VariantParser(const Config& c) : config (c) {}; Variant* parse(); Variant* parse(Variant* v); private: Config config; template void parse_attribute(const std::string& key, T& target); void parse_attribute(const std::string& key, PieceType& target, std::string pieceToChar); }; #endif // #ifndef PARSER_H_INCLUDEDFairy-Stockfish-fairy_sf_11_1/src/partner.cpp000066400000000000000000000120241366242550200213560ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #include #include #include #include "partner.h" #include "thread.h" #include "uci.h" PartnerHandler Partner; // Global object void PartnerHandler::reset() { fast = sitRequested = partnerDead = weDead = weWin = false; time = opptime = 0; } template void PartnerHandler::ptell(const std::string& message) { if (p == ALL_PARTNERS || (p == FAIRY && isFairy) || (p == HUMAN && !isFairy)) sync_cout << "tellics ptell " << message << sync_endl; } void PartnerHandler::parse_partner(std::istringstream& is) { std::string token; if (is >> token) // handshake to identify Fairy-Stockfish ptell("partner Fairy-Stockfish is an engine. Ask it 'help' for supported commands."); else isFairy = false; } void PartnerHandler::parse_ptell(std::istringstream& is, const Position& pos) { std::string token; is >> token; if (token == "partner") { // handshake to identify Fairy-Stockfish if (is >> token && token == "Fairy-Stockfish") isFairy = true; } else if (token == "help") { if (!(is >> token)) { ptell("I listen to the commands help, sit, go, move, fast, slow, dead, x, time, and otim."); ptell("Tell 'help sit', etc. for details."); } else if (token == "sit") ptell("After receiving 'sit', I stop moving. Also see 'go'."); else if (token == "go") ptell("After receiving 'go', I will no longer sit."); else if (token == "move") { ptell("After receiving 'move', I will move immediately." ); ptell("If you specify a valid move, e.g., 'move e2e4', I will play it."); } else if (token == "fast") ptell("After receiving 'go', I will play fast."); else if (token == "slow") ptell("After receiving 'slow', I will play at normal speed."); else if (token == "dead") ptell("After receiving 'dead', I assume you are dead and I play fast."); else if (token == "x") ptell("After receiving 'x', I assume I can play normally again."); else if (token == "time") { ptell("'time' together with your time in centiseconds allows me to consider your time."); ptell("E.g., 'time 1000' for 10 seconds."); } else if (token == "otim") ptell("'otim' together with your opponent's time in centiseconds allows me to consider his time."); } else if (!pos.two_boards()) return; else if (token == "sit") { // Avoid deadlocking sit if (!isFairy || !weWin) sitRequested = true; ptell("I sit, tell me 'go' to continue"); } else if (token == "go") { sitRequested = false; Threads.stop = true; } else if (token == "move") { if (is >> token) { // if the given move is valid and we can still abort the search, play it Move move = UCI::to_move(pos, token); if (move && !Threads.abort.exchange(true)) moveRequested = move; else ptell("sorry, not possible"); } else Threads.stop = true; } else if (token == "fast") { fast = true; ptell("I play fast, tell me 'slow' to play normally again"); } else if (token == "slow") { fast = false; ptell("I play at normal speed again."); } else if (token == "dead") { partnerDead = true; ptell("I play fast, tell me 'x' if you are no longer dead."); } else if (token == "x") { partnerDead = false; sitRequested = false; ptell("I play normally again"); } else if (token == "time") { int value; time = (is >> value) ? value : 0; } else if (token == "otim") { int value; opptime = (is >> value) ? value : 0; } } template void PartnerHandler::ptell(const std::string&); template void PartnerHandler::ptell(const std::string&); template void PartnerHandler::ptell(const std::string&); Fairy-Stockfish-fairy_sf_11_1/src/partner.h000066400000000000000000000027731366242550200210350ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #ifndef PARTNER_H_INCLUDED #define PARTNER_H_INCLUDED #include #include #include "position.h" /// PartnerHandler manages the communication with the partner /// in games played on two boards, such as bughouse. enum PartnerType { HUMAN, FAIRY, ALL_PARTNERS }; struct PartnerHandler { void reset(); template void ptell(const std::string& message); void parse_partner(std::istringstream& is); void parse_ptell(std::istringstream& is, const Position& pos); std::atomic isFairy; std::atomic fast, sitRequested, partnerDead, weDead, weWin; std::atomic time, opptime; Move moveRequested; }; extern PartnerHandler Partner; #endif // #ifndef PARTNER_H_INCLUDEDFairy-Stockfish-fairy_sf_11_1/src/pawns.cpp000066400000000000000000000244351366242550200210440ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include "bitboard.h" #include "pawns.h" #include "position.h" #include "thread.h" namespace { #define V Value #define S(mg, eg) make_score(mg, eg) // Pawn penalties constexpr Score Backward = S( 9, 24); constexpr Score BlockedStorm = S(82, 82); constexpr Score Doubled = S(11, 56); constexpr Score Isolated = S( 5, 15); constexpr Score WeakLever = S( 0, 56); constexpr Score WeakUnopposed = S(13, 27); // Connected pawn bonus constexpr int Connected[RANK_NB] = { 0, 7, 8, 12, 29, 48, 86 }; // Strength of pawn shelter for our king by [distance from edge][rank]. // RANK_1 = 0 is used for files where we have no pawn, or pawn is behind our king. constexpr Value ShelterStrength[int(FILE_NB) / 2][RANK_NB] = { { V( -6), V( 81), V( 93), V( 58), V( 39), V( 18), V( 25) }, { V(-43), V( 61), V( 35), V(-49), V(-29), V(-11), V( -63) }, { V(-10), V( 75), V( 23), V( -2), V( 32), V( 3), V( -45) }, { V(-39), V(-13), V(-29), V(-52), V(-48), V(-67), V(-166) } }; // Danger of enemy pawns moving toward our king by [distance from edge][rank]. // RANK_1 = 0 is used for files where the enemy has no pawn, or their pawn // is behind our king. Note that UnblockedStorm[0][1-2] accommodate opponent pawn // on edge, likely blocked by our king. constexpr Value UnblockedStorm[int(FILE_NB) / 2][RANK_NB] = { { V( 85), V(-289), V(-166), V(97), V(50), V( 45), V( 50) }, { V( 46), V( -25), V( 122), V(45), V(37), V(-10), V( 20) }, { V( -6), V( 51), V( 168), V(34), V(-2), V(-22), V(-14) }, { V(-15), V( -11), V( 101), V( 4), V(11), V(-15), V(-29) } }; #undef S #undef V template Score evaluate(const Position& pos, Pawns::Entry* e) { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); constexpr Direction Up = pawn_push(Us); Bitboard neighbours, stoppers, support, phalanx, opposed; Bitboard lever, leverPush, blocked; Square s; bool backward, passed, doubled; Score score = SCORE_ZERO; const Square* pl = pos.squares(Us); Bitboard ourPawns = pos.pieces( Us, PAWN); Bitboard theirPawns = pos.pieces(Them, PAWN); Bitboard doubleAttackThem = pawn_double_attacks_bb(theirPawns); e->passedPawns[Us] = 0; e->kingSquares[Us] = SQ_NONE; e->pawnAttacks[Us] = e->pawnAttacksSpan[Us] = pawn_attacks_bb(ourPawns); // Loop through all pawns of the current color and score each pawn while ((s = *pl++) != SQ_NONE) { assert(pos.piece_on(s) == make_piece(Us, PAWN)); Rank r = relative_rank(Us, s, pos.max_rank()); // Flag the pawn opposed = theirPawns & forward_file_bb(Us, s); blocked = is_ok(s + Up) ? theirPawns & (s + Up) : Bitboard(0); stoppers = theirPawns & passed_pawn_span(Us, s); lever = theirPawns & PseudoAttacks[Us][PAWN][s]; leverPush = relative_rank(Them, s, pos.max_rank()) > RANK_1 ? theirPawns & PseudoAttacks[Us][PAWN][s + Up] : Bitboard(0); doubled = r > RANK_1 ? ourPawns & (s - Up) : Bitboard(0); neighbours = ourPawns & adjacent_files_bb(s); phalanx = neighbours & rank_bb(s); support = r > RANK_1 ? neighbours & rank_bb(s - Up) : Bitboard(0); // A pawn is backward when it is behind all pawns of the same color on // the adjacent files and cannot safely advance. backward = is_ok(s + Up) && !(neighbours & forward_ranks_bb(Them, s + Up)) && (stoppers & blocked); // Compute additional span if pawn is not backward nor blocked if (!backward && !blocked) e->pawnAttacksSpan[Us] |= pawn_attack_span(Us, s); // A pawn is passed if one of the three following conditions is true: // (a) there is no stoppers except some levers // (b) the only stoppers are the leverPush, but we outnumber them // (c) there is only one front stopper which can be levered. passed = !(stoppers ^ lever) || ( !(stoppers ^ leverPush) && popcount(phalanx) >= popcount(leverPush)) || ( stoppers == blocked && r >= RANK_5 && (shift(support) & ~(theirPawns | doubleAttackThem))); // Passed pawns will be properly scored later in evaluation when we have // full attack info. if (passed && is_ok(s + Up) && (r < pos.promotion_rank() || !pos.mandatory_pawn_promotion())) e->passedPawns[Us] |= s; // Score this pawn if ((support | phalanx) && (r < pos.promotion_rank() || !pos.mandatory_pawn_promotion())) { int v = Connected[r] * (2 + bool(phalanx) - bool(opposed)) * (r == RANK_2 && pos.captures_to_hand() ? 3 : 1) + 21 * popcount(support); if (r >= RANK_4 && pos.count(Us) > popcount(pos.board_bb()) / 4) v = std::max(v, popcount(support | phalanx) * 50) / (opposed ? 2 : 1); score += make_score(v, v * (r - 2) / 4); } else if (!neighbours) score -= Isolated * (1 + 2 * pos.must_capture()) + WeakUnopposed * !opposed; else if (backward) score -= Backward + WeakUnopposed * !opposed; if (!support) score -= Doubled * doubled + WeakLever * more_than_one(lever); } // Double pawn evaluation if there are no non-pawn pieces if (pos.count(Us) == pos.count(Us)) score = score * 2; const Square* pl_shogi = pos.squares(Us); ourPawns = pos.pieces(Us, SHOGI_PAWN); theirPawns = pos.pieces(Them, SHOGI_PAWN); // Loop through all shogi pawns of the current color and score each one while ((s = *pl_shogi++) != SQ_NONE) { assert(pos.piece_on(s) == make_piece(Us, SHOGI_PAWN)); neighbours = ourPawns & adjacent_files_bb(s); if (!neighbours) score -= Isolated / 2; } return score; } } // namespace namespace Pawns { /// Pawns::probe() looks up the current position's pawns configuration in /// the pawns hash table. It returns a pointer to the Entry if the position /// is found. Otherwise a new Entry is computed and stored there, so we don't /// have to recompute all when the same pawns configuration occurs again. Entry* probe(const Position& pos) { Key key = pos.pawn_key(); Entry* e = pos.this_thread()->pawnsTable[key]; if (e->key == key && !pos.pieces(SHOGI_PAWN)) return e; e->key = key; e->scores[WHITE] = evaluate(pos, e); e->scores[BLACK] = evaluate(pos, e); return e; } /// Entry::evaluate_shelter() calculates the shelter bonus and the storm /// penalty for a king, looking at the king file and the two closest files. template Score Entry::evaluate_shelter(const Position& pos, Square ksq) { constexpr Color Them = (Us == WHITE ? BLACK : WHITE); Bitboard b = pos.pieces(PAWN, SHOGI_PAWN) & ~forward_ranks_bb(Them, ksq); Bitboard ourPawns = b & pos.pieces(Us); Bitboard theirPawns = b & pos.pieces(Them); Score bonus = make_score(5, 5); File center = clamp(file_of(ksq), FILE_B, File(pos.max_file() - 1)); for (File f = File(center - 1); f <= File(center + 1); ++f) { b = ourPawns & file_bb(f); int ourRank = b ? relative_rank(Us, frontmost_sq(Them, b), pos.max_rank()) : 0; b = theirPawns & file_bb(f); int theirRank = b ? relative_rank(Us, frontmost_sq(Them, b), pos.max_rank()) : 0; int d = std::min(std::min(f, File(pos.max_file() - f)), FILE_D); bonus += make_score(ShelterStrength[d][ourRank], 0) * (1 + (pos.captures_to_hand() && ourRank <= RANK_2) + (pos.check_counting() && d == 0 && ourRank == RANK_2)); if (ourRank && (ourRank == theirRank - 1)) bonus -= BlockedStorm * int(theirRank == RANK_3); else bonus -= make_score(UnblockedStorm[d][theirRank], 0); } return bonus; } /// Entry::do_king_safety() calculates a bonus for king safety. It is called only /// when king square changes, which is about 20% of total king_safety() calls. template Score Entry::do_king_safety(const Position& pos) { Square ksq = pos.square(Us); kingSquares[Us] = ksq; castlingRights[Us] = pos.castling_rights(Us); auto compare = [](Score a, Score b) { return mg_value(a) < mg_value(b); }; Score shelter = evaluate_shelter(pos, ksq); // If we can castle use the bonus after castling if it is bigger if (pos.can_castle(Us & KING_SIDE)) shelter = std::max(shelter, evaluate_shelter(pos, make_square(pos.castling_kingside_file(), pos.castling_rank(Us))), compare); if (pos.can_castle(Us & QUEEN_SIDE)) shelter = std::max(shelter, evaluate_shelter(pos, make_square(pos.castling_queenside_file(), pos.castling_rank(Us))), compare); // In endgame we like to bring our king near our closest pawn Bitboard pawns = pos.pieces(Us, PAWN); int minPawnDist = pawns ? 8 : 0; if (pawns & PseudoAttacks[Us][KING][ksq]) minPawnDist = 1; else while (pawns) minPawnDist = std::min(minPawnDist, distance(ksq, pop_lsb(&pawns))); return shelter - make_score(0, 16 * minPawnDist); } // Explicit template instantiation template Score Entry::do_king_safety(const Position& pos); template Score Entry::do_king_safety(const Position& pos); } // namespace Pawns Fairy-Stockfish-fairy_sf_11_1/src/pawns.h000066400000000000000000000044761366242550200205140ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef PAWNS_H_INCLUDED #define PAWNS_H_INCLUDED #include "misc.h" #include "position.h" #include "types.h" namespace Pawns { /// Pawns::Entry contains various information about a pawn structure. A lookup /// to the pawn hash table (performed by calling the probe function) returns a /// pointer to an Entry object. struct Entry { Score pawn_score(Color c) const { return scores[c]; } Bitboard pawn_attacks(Color c) const { return pawnAttacks[c]; } Bitboard passed_pawns(Color c) const { return passedPawns[c]; } Bitboard pawn_attacks_span(Color c) const { return pawnAttacksSpan[c]; } int passed_count() const { return popcount(passedPawns[WHITE] | passedPawns[BLACK]); } template Score king_safety(const Position& pos) { return kingSquares[Us] == pos.square(Us) && castlingRights[Us] == pos.castling_rights(Us) ? kingSafety[Us] : (kingSafety[Us] = do_king_safety(pos)); } template Score do_king_safety(const Position& pos); template Score evaluate_shelter(const Position& pos, Square ksq); Key key; Score scores[COLOR_NB]; Bitboard passedPawns[COLOR_NB]; Bitboard pawnAttacks[COLOR_NB]; Bitboard pawnAttacksSpan[COLOR_NB]; Square kingSquares[COLOR_NB]; Score kingSafety[COLOR_NB]; int castlingRights[COLOR_NB]; }; typedef HashTable Table; Entry* probe(const Position& pos); } // namespace Pawns #endif // #ifndef PAWNS_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/piece.cpp000066400000000000000000000307371366242550200210030ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #include #include "types.h" #include "piece.h" PieceMap pieceMap; // Global object void PieceInfo::merge(const PieceInfo* pi) { stepsQuiet.insert(stepsQuiet.end(), pi->stepsQuiet.begin(), pi->stepsQuiet.end()); stepsCapture.insert(stepsCapture.end(), pi->stepsCapture.begin(), pi->stepsCapture.end()); sliderQuiet.insert(sliderQuiet.end(), pi->sliderQuiet.begin(), pi->sliderQuiet.end()); sliderCapture.insert(sliderCapture.end(), pi->sliderCapture.begin(), pi->sliderCapture.end()); } namespace { PieceInfo* pawn_piece() { PieceInfo* p = new PieceInfo(); p->name = "pawn"; p->betza = "fmWfceF"; p->stepsQuiet = {NORTH}; p->stepsCapture = {NORTH_WEST, NORTH_EAST}; return p; } PieceInfo* knight_piece() { PieceInfo* p = new PieceInfo(); p->name = "knight"; p->betza = "N"; p->stepsQuiet = {2 * SOUTH + WEST, 2 * SOUTH + EAST, SOUTH + 2 * WEST, SOUTH + 2 * EAST, NORTH + 2 * WEST, NORTH + 2 * EAST, 2 * NORTH + WEST, 2 * NORTH + EAST }; p->stepsCapture = {2 * SOUTH + WEST, 2 * SOUTH + EAST, SOUTH + 2 * WEST, SOUTH + 2 * EAST, NORTH + 2 * WEST, NORTH + 2 * EAST, 2 * NORTH + WEST, 2 * NORTH + EAST }; return p; } PieceInfo* bishop_piece() { PieceInfo* p = new PieceInfo(); p->name = "bishop"; p->betza = "B"; p->sliderQuiet = {NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST}; p->sliderCapture = {NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST}; return p; } PieceInfo* rook_piece() { PieceInfo* p = new PieceInfo(); p->name = "rook"; p->betza = "R"; p->sliderQuiet = {NORTH, EAST, SOUTH, WEST}; p->sliderCapture = {NORTH, EAST, SOUTH, WEST}; return p; } PieceInfo* queen_piece() { PieceInfo* p = new PieceInfo(); p->name = "queen"; p->betza = "RB"; p->sliderQuiet = {NORTH, EAST, SOUTH, WEST, NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST}; p->sliderCapture = {NORTH, EAST, SOUTH, WEST, NORTH_EAST, SOUTH_EAST, SOUTH_WEST, NORTH_WEST}; return p; } PieceInfo* king_piece() { PieceInfo* p = new PieceInfo(); p->name = "king"; p->betza = "K"; p->stepsQuiet = {SOUTH_WEST, SOUTH, SOUTH_EAST, WEST, EAST, NORTH_WEST, NORTH, NORTH_EAST}; p->stepsCapture = {SOUTH_WEST, SOUTH, SOUTH_EAST, WEST, EAST, NORTH_WEST, NORTH, NORTH_EAST}; return p; } PieceInfo* commoner_piece() { PieceInfo* p = king_piece(); p->name = "commoner"; return p; } PieceInfo* fers_piece() { PieceInfo* p = new PieceInfo(); p->name = "fers"; p->betza = "F"; p->stepsQuiet = {SOUTH_WEST, SOUTH_EAST, NORTH_WEST, NORTH_EAST}; p->stepsCapture = {SOUTH_WEST, SOUTH_EAST, NORTH_WEST, NORTH_EAST}; return p; } PieceInfo* wazir_piece() { PieceInfo* p = new PieceInfo(); p->name = "wazir"; p->betza = "W"; p->stepsQuiet = {SOUTH, WEST, EAST, NORTH}; p->stepsCapture = {SOUTH, WEST, EAST, NORTH}; return p; } PieceInfo* alfil_piece() { PieceInfo* p = new PieceInfo(); p->name = "alfil"; p->betza = "A"; p->stepsQuiet = {2 * SOUTH_WEST, 2 * SOUTH_EAST, 2 * NORTH_WEST, 2 * NORTH_EAST}; p->stepsCapture = {2 * SOUTH_WEST, 2 * SOUTH_EAST, 2 * NORTH_WEST, 2 * NORTH_EAST}; return p; } PieceInfo* fers_alfil_piece() { PieceInfo* p = fers_piece(); p->name = "fersAlfil"; p->betza = "FA"; PieceInfo* p2 = alfil_piece(); p->merge(p2); delete p2; return p; } PieceInfo* silver_piece() { PieceInfo* p = new PieceInfo(); p->name = "silver"; p->betza = "FfW"; p->stepsQuiet = {SOUTH_WEST, SOUTH_EAST, NORTH_WEST, NORTH, NORTH_EAST}; p->stepsCapture = {SOUTH_WEST, SOUTH_EAST, NORTH_WEST, NORTH, NORTH_EAST}; return p; } PieceInfo* aiwok_piece() { PieceInfo* p = rook_piece(); p->name = "aiwok"; p->betza = "RNF"; PieceInfo* p2 = knight_piece(); PieceInfo* p3 = fers_piece(); p->merge(p2); p->merge(p3); delete p2; delete p3; return p; } PieceInfo* bers_piece() { PieceInfo* p = rook_piece(); p->name = "bers"; p->betza = "RF"; PieceInfo* p2 = fers_piece(); p->merge(p2); delete p2; return p; } PieceInfo* archbishop_piece() { PieceInfo* p = bishop_piece(); p->name = "archbishop"; p->betza = "BN"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; return p; } PieceInfo* chancellor_piece() { PieceInfo* p = rook_piece(); p->name = "chancellor"; p->betza = "RN"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; return p; } PieceInfo* amazon_piece() { PieceInfo* p = queen_piece(); p->name = "amazon"; p->betza = "RBN"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; return p; } PieceInfo* knibis_piece() { PieceInfo* p = bishop_piece(); p->name = "knibis"; p->betza = "mNcB"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; p->stepsCapture = {}; p->sliderQuiet = {}; return p; } PieceInfo* biskni_piece() { PieceInfo* p = bishop_piece(); p->name = "biskni"; p->betza = "mBcN"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; p->stepsQuiet = {}; p->sliderCapture = {}; return p; } PieceInfo* kniroo_piece() { PieceInfo* p = rook_piece(); p->name = "kniroo"; p->betza = "mNcR"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; p->stepsCapture = {}; p->sliderQuiet = {}; return p; } PieceInfo* rookni_piece() { PieceInfo* p = rook_piece(); p->name = "rookni"; p->betza = "mRcN"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; p->stepsQuiet = {}; p->sliderCapture = {}; return p; } PieceInfo* shogi_pawn_piece() { PieceInfo* p = new PieceInfo(); p->name = "shogiPawn"; p->betza = "fW"; p->stepsQuiet = {NORTH}; p->stepsCapture = {NORTH}; return p; } PieceInfo* lance_piece() { PieceInfo* p = new PieceInfo(); p->name = "lance"; p->betza = "fR"; p->sliderQuiet = {NORTH}; p->sliderCapture = {NORTH}; return p; } PieceInfo* shogi_knight_piece() { PieceInfo* p = new PieceInfo(); p->name = "shogiKnight"; p->betza = "fN"; p->stepsQuiet = {2 * NORTH + WEST, 2 * NORTH + EAST}; p->stepsCapture = {2 * NORTH + WEST, 2 * NORTH + EAST}; return p; } PieceInfo* euroshogi_knight_piece() { PieceInfo* p = shogi_knight_piece(); p->name = "euroshogiKnight"; p->betza = "fNsW"; p->stepsQuiet.push_back(WEST); p->stepsQuiet.push_back(EAST); p->stepsCapture.push_back(WEST); p->stepsCapture.push_back(EAST); return p; } PieceInfo* gold_piece() { PieceInfo* p = new PieceInfo(); p->name = "gold"; p->betza = "WfF"; p->stepsQuiet = {SOUTH, WEST, EAST, NORTH_WEST, NORTH, NORTH_EAST}; p->stepsCapture = {SOUTH, WEST, EAST, NORTH_WEST, NORTH, NORTH_EAST}; return p; } PieceInfo* dragon_horse_piece() { PieceInfo* p = bishop_piece(); p->name = "dragonHorse"; p->betza = "BW"; PieceInfo* p2 = wazir_piece(); p->merge(p2); delete p2; return p; } PieceInfo* clobber_piece() { PieceInfo* p = wazir_piece(); p->name = "clobber"; p->betza = "cW"; p->stepsQuiet = {}; return p; } PieceInfo* breakthrough_piece() { PieceInfo* p = pawn_piece(); p->name = "breakthrough"; p->betza = "fWfFcF"; p->stepsQuiet.push_back(NORTH_WEST); p->stepsQuiet.push_back(NORTH_EAST); return p; } PieceInfo* immobile_piece() { PieceInfo* p = new PieceInfo(); p->name = "immobile"; return p; } PieceInfo* cannon_piece() { PieceInfo* p = new PieceInfo(); p->name = "cannon"; p->betza = "mRcpR"; p->sliderQuiet = {NORTH, EAST, SOUTH, WEST}; p->hopperCapture = {NORTH, EAST, SOUTH, WEST}; return p; } PieceInfo* janggi_cannon_piece() { PieceInfo* p = new PieceInfo(); p->name = "janggiCannon"; p->betza = "pR"; p->hopperQuiet = {NORTH, EAST, SOUTH, WEST}; p->hopperCapture = {NORTH, EAST, SOUTH, WEST}; return p; } PieceInfo* soldier_piece() { PieceInfo* p = new PieceInfo(); p->name = "soldier"; p->betza = "fsW"; p->stepsQuiet = {NORTH, WEST, EAST}; p->stepsCapture = {NORTH, WEST, EAST}; return p; } PieceInfo* horse_piece() { PieceInfo* p = knight_piece(); p->name = "horse"; p->betza = "nN"; p->lameLeaper = true; return p; } PieceInfo* elephant_piece() { PieceInfo* p = alfil_piece(); p->name = "elephant"; p->betza = "nA"; p->lameLeaper = true; return p; } PieceInfo* janggi_elephant_piece() { PieceInfo* p = new PieceInfo(); p->name = "janggiElephant"; p->betza = "mafsmafW"; p->stepsQuiet = {SOUTH + 2 * SOUTH_WEST, SOUTH + 2 * SOUTH_EAST, WEST + 2 * SOUTH_WEST, EAST + 2 * SOUTH_EAST, WEST + 2 * NORTH_WEST, EAST + 2 * NORTH_EAST, NORTH + 2 * NORTH_WEST, NORTH + 2 * NORTH_EAST}; p->stepsCapture = {SOUTH + 2 * SOUTH_WEST, SOUTH + 2 * SOUTH_EAST, WEST + 2 * SOUTH_WEST, EAST + 2 * SOUTH_EAST, WEST + 2 * NORTH_WEST, EAST + 2 * NORTH_EAST, NORTH + 2 * NORTH_WEST, NORTH + 2 * NORTH_EAST}; p->lameLeaper = true; return p; } PieceInfo* banner_piece() { PieceInfo* p = rook_piece(); p->name = "banner"; p->betza = "RcpRnN"; PieceInfo* p2 = horse_piece(); p->merge(p2); delete p2; p->hopperCapture = {NORTH, EAST, SOUTH, WEST}; p->lameLeaper = true; return p; } PieceInfo* centaur_piece() { PieceInfo* p = commoner_piece(); p->name = "centaur"; p->betza = "KN"; PieceInfo* p2 = knight_piece(); p->merge(p2); delete p2; return p; } } void PieceMap::init() { add(PAWN, pawn_piece()); add(KNIGHT, knight_piece()); add(BISHOP, bishop_piece()); add(ROOK, rook_piece()); add(QUEEN, queen_piece()); add(FERS, fers_piece()); add(ALFIL, alfil_piece()); add(FERS_ALFIL, fers_alfil_piece()); add(SILVER, silver_piece()); add(AIWOK, aiwok_piece()); add(BERS, bers_piece()); add(ARCHBISHOP, archbishop_piece()); add(CHANCELLOR, chancellor_piece()); add(AMAZON, amazon_piece()); add(KNIBIS, knibis_piece()); add(BISKNI, biskni_piece()); add(KNIROO, kniroo_piece()); add(ROOKNI, rookni_piece()); add(SHOGI_PAWN, shogi_pawn_piece()); add(LANCE, lance_piece()); add(SHOGI_KNIGHT, shogi_knight_piece()); add(EUROSHOGI_KNIGHT, euroshogi_knight_piece()); add(GOLD, gold_piece()); add(DRAGON_HORSE, dragon_horse_piece()); add(CLOBBER_PIECE, clobber_piece()); add(BREAKTHROUGH_PIECE, breakthrough_piece()); add(IMMOBILE_PIECE, immobile_piece()); add(CANNON, cannon_piece()); add(JANGGI_CANNON, janggi_cannon_piece()); add(SOLDIER, soldier_piece()); add(HORSE, horse_piece()); add(ELEPHANT, elephant_piece()); add(JANGGI_ELEPHANT, janggi_elephant_piece()); add(BANNER, banner_piece()); add(WAZIR, wazir_piece()); add(COMMONER, commoner_piece()); add(CENTAUR, centaur_piece()); add(KING, king_piece()); } void PieceMap::add(PieceType pt, const PieceInfo* p) { insert(std::pair(pt, p)); } void PieceMap::clear_all() { for (auto const& element : *this) delete element.second; clear(); } Fairy-Stockfish-fairy_sf_11_1/src/piece.h000066400000000000000000000030371366242550200204410ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #ifndef PIECE_H_INCLUDED #define PIECE_H_INCLUDED #include #include #include #include "types.h" /// PieceInfo struct stores information about the piece movements. struct PieceInfo { std::string name = ""; std::string betza = ""; std::vector stepsQuiet = {}; std::vector stepsCapture = {}; std::vector sliderQuiet = {}; std::vector sliderCapture = {}; std::vector hopperQuiet = {}; std::vector hopperCapture = {}; bool lameLeaper = false; void merge(const PieceInfo* pi); }; struct PieceMap : public std::map { void init(); void add(PieceType pt, const PieceInfo* v); void clear_all(); }; extern PieceMap pieceMap; #endif // #ifndef PIECE_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/position.cpp000066400000000000000000002225561366242550200215640ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include // For offsetof() #include // For std::memset, std::memcmp #include #include #include "bitboard.h" #include "misc.h" #include "movegen.h" #include "position.h" #include "thread.h" #include "tt.h" #include "uci.h" #include "syzygy/tbprobe.h" using std::string; namespace Zobrist { Key psq[PIECE_NB][SQUARE_NB]; Key enpassant[FILE_NB]; Key castling[CASTLING_RIGHT_NB]; Key side, noPawns; Key inHand[PIECE_NB][SQUARE_NB]; Key checks[COLOR_NB][CHECKS_NB]; } /// operator<<(Position) returns an ASCII representation of the position std::ostream& operator<<(std::ostream& os, const Position& pos) { os << "\n "; for (File f = FILE_A; f <= pos.max_file(); ++f) os << "+---"; os << "+\n"; for (Rank r = pos.max_rank(); r >= RANK_1; --r) { for (File f = FILE_A; f <= pos.max_file(); ++f) if (pos.unpromoted_piece_on(make_square(f, r))) os << " |+" << pos.piece_to_char()[pos.unpromoted_piece_on(make_square(f, r))]; else os << " | " << pos.piece_to_char()[pos.piece_on(make_square(f, r))]; os << " |"; if (r == pos.max_rank() || r == RANK_1) { Color c = r == RANK_1 ? WHITE : BLACK; if (c == pos.side_to_move()) os << " *"; else os << " "; if (pos.piece_drops() || pos.seirawan_gating()) { os << " ["; for (PieceType pt = KING; pt >= PAWN; --pt) os << std::string(pos.count_in_hand(c, pt), pos.piece_to_char()[make_piece(c, pt)]); os << "]"; } } os << "\n "; for (File f = FILE_A; f <= pos.max_file(); ++f) os << "+---"; os << "+\n"; } os << "\nFen: " << pos.fen() << "\nSfen: " << pos.fen(true) << "\nKey: " << std::hex << std::uppercase << std::setfill('0') << std::setw(16) << pos.key() << std::setfill(' ') << std::dec << "\nCheckers: "; for (Bitboard b = pos.checkers(); b; ) os << UCI::square(pos, pop_lsb(&b)) << " "; if ( int(Tablebases::MaxCardinality) >= popcount(pos.pieces()) && Options["UCI_Variant"] == "chess" && !pos.can_castle(ANY_CASTLING)) { StateInfo st; Position p; p.set(pos.variant(), pos.fen(), pos.is_chess960(), &st, pos.this_thread()); Tablebases::ProbeState s1, s2; Tablebases::WDLScore wdl = Tablebases::probe_wdl(p, &s1); int dtz = Tablebases::probe_dtz(p, &s2); os << "\nTablebases WDL: " << std::setw(4) << wdl << " (" << s1 << ")" << "\nTablebases DTZ: " << std::setw(4) << dtz << " (" << s2 << ")"; } return os; } // Marcel van Kervinck's cuckoo algorithm for fast detection of "upcoming repetition" // situations. Description of the algorithm in the following paper: // https://marcelk.net/2013-04-06/paper/upcoming-rep-v2.pdf // First and second hash functions for indexing the cuckoo tables #ifdef LARGEBOARDS inline int H1(Key h) { return h & 0x7fff; } inline int H2(Key h) { return (h >> 16) & 0x7fff; } #else inline int H1(Key h) { return h & 0x1fff; } inline int H2(Key h) { return (h >> 16) & 0x1fff; } #endif // Cuckoo tables with Zobrist hashes of valid reversible moves, and the moves themselves #ifdef LARGEBOARDS Key cuckoo[65536]; Move cuckooMove[65536]; #else Key cuckoo[8192]; Move cuckooMove[8192]; #endif /// Position::init() initializes at startup the various arrays used to compute /// hash keys. void Position::init() { PRNG rng(1070372); for (Color c : {WHITE, BLACK}) for (PieceType pt = PAWN; pt <= KING; ++pt) for (Square s = SQ_A1; s <= SQ_MAX; ++s) Zobrist::psq[make_piece(c, pt)][s] = rng.rand(); for (File f = FILE_A; f <= FILE_MAX; ++f) Zobrist::enpassant[f] = rng.rand(); for (int cr = NO_CASTLING; cr <= ANY_CASTLING; ++cr) { Zobrist::castling[cr] = 0; Bitboard b = cr; while (b) { Key k = Zobrist::castling[1ULL << pop_lsb(&b)]; Zobrist::castling[cr] ^= k ? k : rng.rand(); } } Zobrist::side = rng.rand(); Zobrist::noPawns = rng.rand(); for (Color c : {WHITE, BLACK}) for (int n = 0; n < CHECKS_NB; ++n) Zobrist::checks[c][n] = rng.rand(); for (Color c : {WHITE, BLACK}) for (PieceType pt = PAWN; pt <= KING; ++pt) for (int n = 0; n < SQUARE_NB; ++n) Zobrist::inHand[make_piece(c, pt)][n] = rng.rand(); // Prepare the cuckoo tables std::memset(cuckoo, 0, sizeof(cuckoo)); std::memset(cuckooMove, 0, sizeof(cuckooMove)); int count = 0; for (Color c : {WHITE, BLACK}) for (PieceType pt = KNIGHT; pt <= QUEEN || pt == KING; pt != QUEEN ? ++pt : pt = KING) { Piece pc = make_piece(c, pt); for (Square s1 = SQ_A1; s1 <= SQ_MAX; ++s1) for (Square s2 = Square(s1 + 1); s2 <= SQ_MAX; ++s2) if (PseudoAttacks[WHITE][type_of(pc)][s1] & s2) { Move move = make_move(s1, s2); Key key = Zobrist::psq[pc][s1] ^ Zobrist::psq[pc][s2] ^ Zobrist::side; int i = H1(key); while (true) { std::swap(cuckoo[i], key); std::swap(cuckooMove[i], move); if (move == MOVE_NONE) // Arrived at empty slot? break; i = (i == H1(key)) ? H2(key) : H1(key); // Push victim to alternative slot } count++; } } #ifdef LARGEBOARDS assert(count == 9344); #else assert(count == 3668); #endif } /// Position::set() initializes the position object with the given FEN string. /// This function is not very robust - make sure that input FENs are correct, /// this is assumed to be the responsibility of the GUI. Position& Position::set(const Variant* v, const string& fenStr, bool isChess960, StateInfo* si, Thread* th, bool sfen) { /* A FEN string defines a particular position using only the ASCII character set. A FEN string contains six fields separated by a space. The fields are: 1) Piece placement (from white's perspective). Each rank is described, starting with rank 8 and ending with rank 1. Within each rank, the contents of each square are described from file A through file H. Following the Standard Algebraic Notation (SAN), each piece is identified by a single letter taken from the standard English names. White pieces are designated using upper-case letters ("PNBRQK") whilst Black uses lowercase ("pnbrqk"). Blank squares are noted using digits 1 through 8 (the number of blank squares), and "/" separates ranks. 2) Active color. "w" means white moves next, "b" means black. 3) Castling availability. If neither side can castle, this is "-". Otherwise, this has one or more letters: "K" (White can castle kingside), "Q" (White can castle queenside), "k" (Black can castle kingside), and/or "q" (Black can castle queenside). 4) En passant target square (in algebraic notation). If there's no en passant target square, this is "-". If a pawn has just made a 2-square move, this is the position "behind" the pawn. This is recorded only if there is a pawn in position to make an en passant capture, and if there really is a pawn that might have advanced two squares. 5) Halfmove clock. This is the number of halfmoves since the last pawn advance or capture. This is used to determine if a draw can be claimed under the fifty-move rule. 6) Fullmove number. The number of the full move. It starts at 1, and is incremented after Black's move. */ unsigned char col, row, token; size_t idx; std::istringstream ss(fenStr); std::memset(static_cast(this), 0, sizeof(Position)); std::memset(static_cast(si), 0, sizeof(StateInfo)); std::fill_n(&pieceList[0][0], sizeof(pieceList) / sizeof(Square), SQ_NONE); var = v; st = si; ss >> std::noskipws; Square sq = SQ_A1 + max_rank() * NORTH; // 1. Piece placement while ((ss >> token) && !isspace(token)) { if (isdigit(token)) { #ifdef LARGEBOARDS if (isdigit(ss.peek())) { sq += 10 * (token - '0') * EAST; ss >> token; } #endif sq += (token - '0') * EAST; // Advance the given number of files } else if (token == '/') { sq += 2 * SOUTH + (FILE_MAX - max_file()) * EAST; if (!is_ok(sq)) break; } else if ((idx = piece_to_char().find(token)) != string::npos || (idx = piece_to_char_synonyms().find(token)) != string::npos) { if (ss.peek() == '~') ss >> token; put_piece(Piece(idx), sq, token == '~'); ++sq; } // Promoted shogi pieces else if (token == '+') { ss >> token; idx = piece_to_char().find(token); put_piece(make_piece(color_of(Piece(idx)), promoted_piece_type(type_of(Piece(idx)))), sq, true, Piece(idx)); ++sq; } // Stop before pieces in hand else if (token == '[') break; } // Pieces in hand if (!isspace(token)) while ((ss >> token) && !isspace(token)) { if (token == ']') continue; else if ((idx = piece_to_char().find(token)) != string::npos) add_to_hand(Piece(idx)); } // 2. Active color ss >> token; sideToMove = (token == 'w' ? WHITE : BLACK); // Invert side to move for SFEN if (sfen) sideToMove = ~sideToMove; ss >> token; // 3-4. Skip parsing castling and en passant flags if not present st->epSquare = SQ_NONE; if (!isdigit(ss.peek()) && !sfen) { // 3. Castling availability. Compatible with 3 standards: Normal FEN standard, // Shredder-FEN that uses the letters of the columns on which the rooks began // the game instead of KQkq and also X-FEN standard that, in case of Chess960, // if an inner rook is associated with the castling right, the castling tag is // replaced by the file letter of the involved rook, as for the Shredder-FEN. while ((ss >> token) && !isspace(token)) { Square rsq; Color c = islower(token) ? BLACK : WHITE; Piece rook = make_piece(c, castling_rook_piece()); token = char(toupper(token)); if (token == 'K') for (rsq = make_square(FILE_MAX, castling_rank(c)); piece_on(rsq) != rook; --rsq) {} else if (token == 'Q') for (rsq = make_square(FILE_A, castling_rank(c)); piece_on(rsq) != rook; ++rsq) {} else if (token >= 'A' && token <= 'A' + max_file()) rsq = make_square(File(token - 'A'), castling_rank(c)); else continue; // Set gates (and skip castling rights) if (gating()) { st->gatesBB[c] |= rsq; if (token == 'K' || token == 'Q') st->gatesBB[c] |= count(c) ? square(c) : make_square(FILE_E, castling_rank(c)); // Do not set castling rights for gates unless there are no pieces in hand, // which means that the file is referring to a chess960 castling right. else if (!seirawan_gating() || count_in_hand(c, ALL_PIECES) || captures_to_hand()) continue; } if (castling_enabled()) set_castling_right(c, rsq); } // Set castling rights for 960 gating variants if (gating() && castling_enabled()) for (Color c : {WHITE, BLACK}) if ((gates(c) & pieces(KING)) && !castling_rights(c) && (!seirawan_gating() || count_in_hand(c, ALL_PIECES) || captures_to_hand())) { Bitboard castling_rooks = gates(c) & pieces(castling_rook_piece()); while (castling_rooks) set_castling_right(c, pop_lsb(&castling_rooks)); } // counting limit if (counting_rule() && isdigit(ss.peek())) ss >> st->countingLimit; // 4. En passant square. Ignore if no pawn capture is possible else if ( ((ss >> col) && (col >= 'a' && col <= 'a' + max_file())) && ((ss >> row) && (row >= '1' && row <= '1' + max_rank()))) { st->epSquare = make_square(File(col - 'a'), Rank(row - '1')); if ( !(attackers_to(st->epSquare) & pieces(sideToMove, PAWN)) || !(pieces(~sideToMove, PAWN) & (st->epSquare + pawn_push(~sideToMove)))) st->epSquare = SQ_NONE; } } // Check counter for nCheck ss >> std::skipws >> token >> std::noskipws; if (check_counting()) { if (ss.peek() == '+') { st->checksRemaining[WHITE] = CheckCount(std::max(token - '0', 0)); ss >> token >> token; st->checksRemaining[BLACK] = CheckCount(std::max(token - '0', 0)); } else { // If check count is not provided, assume that the next check wins st->checksRemaining[WHITE] = CheckCount(1); st->checksRemaining[BLACK] = CheckCount(1); ss.putback(token); } } else ss.putback(token); // 5-6. Halfmove clock and fullmove number if (sfen) { // Pieces in hand for SFEN int handCount = 1; while ((ss >> token) && !isspace(token)) { if (token == '-') continue; else if (isdigit(token)) { handCount = token - '0'; while (isdigit(ss.peek()) && ss >> token) handCount = 10 * handCount + (token - '0'); } else if ((idx = piece_to_char().find(token)) != string::npos) { for (int i = 0; i < handCount; i++) add_to_hand(Piece(idx)); handCount = 1; } } // Move count is in ply for SFEN ss >> std::skipws >> gamePly; gamePly = std::max(gamePly - 1, 0); } else { ss >> std::skipws >> st->rule50 >> gamePly; // Convert from fullmove starting from 1 to gamePly starting from 0, // handle also common incorrect FEN with fullmove = 0. gamePly = std::max(2 * (gamePly - 1), 0) + (sideToMove == BLACK); } // counting rules if (st->countingLimit && st->rule50) { st->countingPly = st->rule50; st->rule50 = 0; } chess960 = isChess960 || v->chess960; thisThread = th; set_state(st); assert(pos_is_ok()); return *this; } /// Position::set_castling_right() is a helper function used to set castling /// rights given the corresponding color and the rook starting square. void Position::set_castling_right(Color c, Square rfrom) { Square kfrom = count(c) ? square(c) : make_square(FILE_E, castling_rank(c)); CastlingRights cr = c & (kfrom < rfrom ? KING_SIDE: QUEEN_SIDE); st->castlingRights |= cr; castlingRightsMask[kfrom] |= cr; castlingRightsMask[rfrom] |= cr; castlingRookSquare[cr] = rfrom; Square kto = make_square(cr & KING_SIDE ? castling_kingside_file() : castling_queenside_file(), castling_rank(c)); Square rto = kto + (cr & KING_SIDE ? WEST : EAST); castlingPath[cr] = (between_bb(rfrom, rto) | between_bb(kfrom, kto) | rto | kto) & ~(square_bb(kfrom) | rfrom); } /// Position::set_check_info() sets king attacks to detect if a move gives check void Position::set_check_info(StateInfo* si) const { si->blockersForKing[WHITE] = slider_blockers(pieces(BLACK), count(WHITE) ? square(WHITE) : SQ_NONE, si->pinners[BLACK], BLACK); si->blockersForKing[BLACK] = slider_blockers(pieces(WHITE), count(BLACK) ? square(BLACK) : SQ_NONE, si->pinners[WHITE], WHITE); Square ksq = count(~sideToMove) ? square(~sideToMove) : SQ_NONE; // For unused piece types, the check squares are left uninitialized for (PieceType pt : piece_types()) si->checkSquares[pt] = ksq != SQ_NONE ? attacks_bb(~sideToMove, pt, ksq, pieces()) : Bitboard(0); si->checkSquares[KING] = 0; si->shak = si->checkersBB & (byTypeBB[KNIGHT] | byTypeBB[ROOK] | byTypeBB[BERS]); si->bikjang = var->bikjangRule && ksq != SQ_NONE ? bool(attacks_bb(sideToMove, ROOK, ksq, pieces()) & pieces(sideToMove, KING)) : false; } /// Position::set_state() computes the hash keys of the position, and other /// data that once computed is updated incrementally as moves are made. /// The function is only used when a new position is set up, and to verify /// the correctness of the StateInfo data when running in debug mode. void Position::set_state(StateInfo* si) const { si->key = si->materialKey = 0; si->pawnKey = Zobrist::noPawns; si->nonPawnMaterial[WHITE] = si->nonPawnMaterial[BLACK] = VALUE_ZERO; si->checkersBB = count(sideToMove) ? attackers_to(square(sideToMove), ~sideToMove) : Bitboard(0); set_check_info(si); for (Bitboard b = pieces(); b; ) { Square s = pop_lsb(&b); Piece pc = piece_on(s); si->key ^= Zobrist::psq[pc][s]; if (type_of(pc) == PAWN) si->pawnKey ^= Zobrist::psq[pc][s]; else if (type_of(pc) != KING) si->nonPawnMaterial[color_of(pc)] += PieceValue[MG][pc]; } if (si->epSquare != SQ_NONE) si->key ^= Zobrist::enpassant[file_of(si->epSquare)]; if (sideToMove == BLACK) si->key ^= Zobrist::side; si->key ^= Zobrist::castling[si->castlingRights]; for (Color c : {WHITE, BLACK}) for (PieceType pt = PAWN; pt <= KING; ++pt) { Piece pc = make_piece(c, pt); for (int cnt = 0; cnt < pieceCount[pc]; ++cnt) si->materialKey ^= Zobrist::psq[pc][cnt]; if (piece_drops() || seirawan_gating()) si->key ^= Zobrist::inHand[pc][pieceCountInHand[c][pt]]; } if (check_counting()) for (Color c : {WHITE, BLACK}) si->key ^= Zobrist::checks[c][si->checksRemaining[c]]; } /// Position::set() is an overload to initialize the position object with /// the given endgame code string like "KBPKN". It is mainly a helper to /// get the material key out of an endgame code. Position& Position::set(const string& code, Color c, StateInfo* si) { assert(code.length() > 0 && code.length() < 8); assert(code[0] == 'K'); string sides[] = { code.substr(code.find('K', 1)), // Weak code.substr(0, code.find('K', 1)) }; // Strong std::transform(sides[c].begin(), sides[c].end(), sides[c].begin(), tolower); string n = std::to_string(FILE_NB); string fenStr = n + "/" + sides[0] + char(FILE_NB - sides[0].length() + '0') + "/" + n + "/" + n + "/" + n + "/" + n + "/" + sides[1] + char(FILE_NB - sides[1].length() + '0') + "/" + n + " w - - 0 10"; return set(variants.find("fairy")->second, fenStr, false, si, nullptr); } /// Position::fen() returns a FEN representation of the position. In case of /// Chess960 the Shredder-FEN notation is used. This is mainly a debugging function. const string Position::fen(bool sfen, bool showPromoted, int countStarted, std::string holdings) const { int emptyCnt; std::ostringstream ss; for (Rank r = max_rank(); r >= RANK_1; --r) { for (File f = FILE_A; f <= max_file(); ++f) { for (emptyCnt = 0; f <= max_file() && empty(make_square(f, r)); ++f) ++emptyCnt; if (emptyCnt) ss << emptyCnt; if (f <= max_file()) { if (unpromoted_piece_on(make_square(f, r))) // Promoted shogi pieces, e.g., +r for dragon ss << "+" << piece_to_char()[unpromoted_piece_on(make_square(f, r))]; else { ss << piece_to_char()[piece_on(make_square(f, r))]; // Set promoted pieces if (((captures_to_hand() && !drop_loop()) || showPromoted) && is_promoted(make_square(f, r))) ss << "~"; } } } if (r > RANK_1) ss << '/'; } // SFEN if (sfen) { ss << (sideToMove == WHITE ? " b " : " w "); for (Color c : {WHITE, BLACK}) for (PieceType pt = KING; pt >= PAWN; --pt) if (pieceCountInHand[c][pt]) { if (pieceCountInHand[c][pt] > 1) ss << pieceCountInHand[c][pt]; ss << piece_to_char()[make_piece(c, pt)]; } if (!count_in_hand(WHITE, ALL_PIECES) && !count_in_hand(BLACK, ALL_PIECES)) ss << '-'; ss << " " << gamePly + 1; return ss.str(); } // pieces in hand if (piece_drops() || seirawan_gating()) { ss << '['; if (holdings != "-") ss << holdings; else for (Color c : {WHITE, BLACK}) for (PieceType pt = KING; pt >= PAWN; --pt) ss << std::string(pieceCountInHand[c][pt], piece_to_char()[make_piece(c, pt)]); ss << ']'; } ss << (sideToMove == WHITE ? " w " : " b "); if (can_castle(WHITE_OO)) ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OO ))) : 'K'); if (can_castle(WHITE_OOO)) ss << (chess960 ? char('A' + file_of(castling_rook_square(WHITE_OOO))) : 'Q'); if (gating() && gates(WHITE) && (!seirawan_gating() || count_in_hand(WHITE, ALL_PIECES) || captures_to_hand())) for (File f = FILE_A; f <= max_file(); ++f) if (gates(WHITE) & file_bb(f)) ss << char('A' + f); if (can_castle(BLACK_OO)) ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OO ))) : 'k'); if (can_castle(BLACK_OOO)) ss << (chess960 ? char('a' + file_of(castling_rook_square(BLACK_OOO))) : 'q'); if (gating() && gates(BLACK) && (!seirawan_gating() || count_in_hand(BLACK, ALL_PIECES) || captures_to_hand())) for (File f = FILE_A; f <= max_file(); ++f) if (gates(BLACK) & file_bb(f)) ss << char('a' + f); if (!can_castle(ANY_CASTLING) && !(gating() && (gates(WHITE) | gates(BLACK)))) ss << '-'; // Counting limit or ep-square if (st->countingLimit) ss << " " << st->countingLimit << " "; else ss << (ep_square() == SQ_NONE ? " - " : " " + UCI::square(*this, ep_square()) + " "); // Check count if (check_counting()) ss << st->checksRemaining[WHITE] << "+" << st->checksRemaining[BLACK] << " "; // Counting ply or 50-move rule counter if (st->countingLimit) ss << counting_ply(countStarted); else ss << st->rule50; ss << " " << 1 + (gamePly - (sideToMove == BLACK)) / 2; return ss.str(); } /// Position::slider_blockers() returns a bitboard of all the pieces (both colors) /// that are blocking attacks on the square 's' from 'sliders'. A piece blocks a /// slider if removing that piece from the board would result in a position where /// square 's' is attacked. For example, a king-attack blocking piece can be either /// a pinned or a discovered check piece, according if its color is the opposite /// or the same of the color of the slider. Bitboard Position::slider_blockers(Bitboard sliders, Square s, Bitboard& pinners, Color c) const { Bitboard blockers = 0; pinners = 0; if (s == SQ_NONE || !sliders) return blockers; // Snipers are sliders that attack 's' when a piece and other snipers are removed Bitboard snipers = 0; for (PieceType pt : piece_types()) { Bitboard b = sliders & (PseudoAttacks[~c][pt][s] ^ LeaperAttacks[~c][pt][s]) & pieces(c, pt); if (b) { // Consider asymmetrical moves (e.g., horse) if (AttackRiderTypes[pt] & ASYMMETRICAL_RIDERS) { Bitboard asymmetricals = PseudoAttacks[~c][pt][s] & pieces(c, pt); while (asymmetricals) { Square s2 = pop_lsb(&asymmetricals); if (!(attacks_from(c, pt, s2) & s)) snipers |= s2; } } else snipers |= b & ~attacks_bb(~c, pt, s, pieces()); } } Bitboard occupancy = pieces() ^ snipers; while (snipers) { Square sniperSq = pop_lsb(&snipers); Bitboard b = between_bb(s, sniperSq, type_of(piece_on(sniperSq))) & occupancy; if (b && (!more_than_one(b) || ((AttackRiderTypes[type_of(piece_on(sniperSq))] & HOPPING_RIDERS) && popcount(b) == 2))) { // Janggi cannons block each other if ((pieces(JANGGI_CANNON) & sniperSq) && (pieces(JANGGI_CANNON) & b)) b &= pieces(JANGGI_CANNON); blockers |= b; if (b & pieces(color_of(piece_on(s)))) pinners |= sniperSq; } } return blockers; } /// Position::attackers_to() computes a bitboard of all pieces which attack a /// given square. Slider attacks use the occupied bitboard to indicate occupancy. Bitboard Position::attackers_to(Square s, Bitboard occupied, Color c, Bitboard janggiCannons) const { Bitboard b = 0; for (PieceType pt : piece_types()) if (board_bb(c, pt) & s) { PieceType move_pt = pt == KING ? king_type() : pt; // Consider asymmetrical move of horse if (AttackRiderTypes[move_pt] & ASYMMETRICAL_RIDERS) { Bitboard horses = PseudoAttacks[~c][move_pt][s] & pieces(c, pt); while (horses) { Square s2 = pop_lsb(&horses); if (attacks_bb(c, move_pt, s2, occupied) & s) b |= s2; } } else if (pt == JANGGI_CANNON) b |= attacks_bb(~c, move_pt, s, occupied) & attacks_bb(~c, move_pt, s, occupied & ~janggiCannons) & pieces(c, JANGGI_CANNON); else b |= attacks_bb(~c, move_pt, s, occupied) & pieces(c, pt); } // Consider special move of neang in cambodian chess if (cambodian_moves()) { Square fers_sq = s + 2 * (c == WHITE ? SOUTH : NORTH); if (is_ok(fers_sq)) b |= pieces(c, FERS) & gates(c) & fers_sq; } // Janggi palace moves if (diagonal_lines() & s) { Bitboard diags = 0; if (king_type() == WAZIR) diags |= attacks_bb(~c, FERS, s, occupied) & pieces(c, KING); diags |= attacks_bb(~c, FERS, s, occupied) & pieces(c, WAZIR); diags |= attacks_bb(~c, PAWN, s, occupied) & pieces(c, SOLDIER); diags |= attacks_bb(~c, BISHOP, s, occupied) & pieces(c, ROOK); // TODO: fix for longer diagonals diags |= attacks_bb(~c, ALFIL, s, occupied) & ~attacks_bb(~c, ELEPHANT, s, occupied & ~janggiCannons) & pieces(c, JANGGI_CANNON); b |= diags & diagonal_lines(); } if (b & pieces(SOLDIER) && relative_rank(c, s, max_rank()) < var->soldierPromotionRank) b ^= b & pieces(SOLDIER) & ~PseudoAttacks[~c][SHOGI_PAWN][s]; return b; } Bitboard Position::attackers_to(Square s, Bitboard occupied) const { return attackers_to(s, occupied, WHITE) | attackers_to(s, occupied, BLACK); } /// Position::legal() tests whether a pseudo-legal move is legal bool Position::legal(Move m) const { assert(is_ok(m)); assert(type_of(m) != DROP || piece_drops()); Color us = sideToMove; Square from = from_sq(m); Square to = to_sq(m); assert(color_of(moved_piece(m)) == us); assert(!count(us) || piece_on(square(us)) == make_piece(us, KING)); assert(board_bb() & to); // Illegal checks if ((!checking_permitted() || (sittuyin_promotion() && type_of(m) == PROMOTION) || (!drop_checks() && type_of(m) == DROP)) && gives_check(m)) return false; // Illegal quiet moves if (must_capture() && !capture(m)) { if (checkers()) { for (const auto& mevasion : MoveList(*this)) if (capture(mevasion) && legal(mevasion)) return false; } else { for (const auto& mcap : MoveList(*this)) if (capture(mcap) && legal(mcap)) return false; } } // Illegal non-drop moves if (must_drop() && type_of(m) != DROP && count_in_hand(us, var->mustDropType)) { if (checkers()) { for (const auto& mevasion : MoveList(*this)) if (type_of(mevasion) == DROP && legal(mevasion)) return false; } else { for (const auto& mquiet : MoveList(*this)) if (type_of(mquiet) == DROP && legal(mquiet)) return false; } } // Illegal drop move if (drop_opposite_colored_bishop() && type_of(m) == DROP) { if (type_of(moved_piece(m)) != BISHOP) { Bitboard remaining = drop_region(us, BISHOP) & ~pieces() & ~square_bb(to); // Are enough squares available to drop bishops on opposite colors? if ( (!( DarkSquares & pieces(us, BISHOP)) && ( DarkSquares & remaining)) + (!(~DarkSquares & pieces(us, BISHOP)) && (~DarkSquares & remaining)) < count_in_hand(us, BISHOP)) return false; } else // Drop resulting in same-colored bishops if ((DarkSquares & to ? DarkSquares : ~DarkSquares) & pieces(us, BISHOP)) return false; } // No legal moves from target square if (immobility_illegal() && (type_of(m) == DROP || type_of(m) == NORMAL) && !(moves_bb(us, type_of(moved_piece(m)), to, 0) & board_bb())) return false; // Illegal king passing move if (king_pass_on_stalemate() && is_pass(m) && !checkers()) { for (const auto& move : MoveList(*this)) if (!is_pass(move) && legal(move)) return false; } // En passant captures are a tricky special case. Because they are rather // uncommon, we do it simply by testing whether the king is attacked after // the move is made. if (type_of(m) == ENPASSANT) { Square ksq = count(us) ? square(us) : SQ_NONE; Square capsq = to - pawn_push(us); Bitboard occupied = (pieces() ^ from ^ capsq) | to; assert(to == ep_square()); assert(moved_piece(m) == make_piece(us, PAWN)); assert(piece_on(capsq) == make_piece(~us, PAWN)); assert(piece_on(to) == NO_PIECE); return !count(us) || !(attackers_to(ksq, occupied, ~us) & occupied); } // Castling moves generation does not check if the castling path is clear of // enemy attacks, it is delayed at a later time: now! if (type_of(m) == CASTLING) { // Non-royal pieces can not be impeded from castling if (type_of(piece_on(from)) != KING) return true; // After castling, the rook and king final positions are the same in // Chess960 as they would be in standard chess. to = make_square(to > from ? castling_kingside_file() : castling_queenside_file(), castling_rank(us)); Direction step = to > from ? WEST : EAST; for (Square s = to; s != from; s += step) if (attackers_to(s, ~us)) return false; // In case of Chess960, verify that when moving the castling rook we do // not discover some hidden checker. // For instance an enemy queen in SQ_A1 when castling rook is in SQ_B1. return !chess960 || !(attackers_to(to, pieces() ^ to_sq(m), ~us)); } Bitboard occupied = (type_of(m) != DROP ? pieces() ^ from : pieces()) | to; // Flying general rule and bikjang // In case of bikjang passing is always allowed, even when in check if (st->bikjang && is_pass(m)) return true; if ((var->flyingGeneral && count(us)) || st->bikjang) { Square s = type_of(moved_piece(m)) == KING ? to : square(us); if (attacks_bb(~us, ROOK, s, occupied) & pieces(~us, KING) & ~square_bb(to)) return false; } // Makpong rule if (var->makpongRule && checkers() && type_of(moved_piece(m)) == KING && (checkers() ^ to)) return false; // If the moving piece is a king, check whether the destination // square is attacked by the opponent. Castling moves are checked // for legality during move generation. if (type_of(moved_piece(m)) == KING) return type_of(m) == CASTLING || !attackers_to(to, occupied, ~us); Bitboard janggiCannons = pieces(JANGGI_CANNON); if (type_of(moved_piece(m)) == JANGGI_CANNON) janggiCannons = (type_of(m) == DROP ? janggiCannons : janggiCannons ^ from) | to; else if (janggiCannons & to) janggiCannons ^= to; // A non-king move is legal if the king is not under attack after the move. return !count(us) || !(attackers_to(square(us), occupied, ~us, janggiCannons) & ~SquareBB[to]); } /// Position::pseudo_legal() takes a random move and tests whether the move is /// pseudo legal. It is used to validate moves from TT that can be corrupted /// due to SMP concurrent access or hash position key aliasing. bool Position::pseudo_legal(const Move m) const { Color us = sideToMove; Square from = from_sq(m); Square to = to_sq(m); Piece pc = moved_piece(m); // Illegal moves to squares outside of board if (!(board_bb() & to)) return false; // Use a fast check for piece drops if (type_of(m) == DROP) return piece_drops() && pc != NO_PIECE && color_of(pc) == us && count_in_hand(us, in_hand_piece_type(m)) && (drop_region(us, type_of(pc)) & ~pieces() & to) && ( type_of(pc) == in_hand_piece_type(m) || (drop_promoted() && type_of(pc) == promoted_piece_type(in_hand_piece_type(m)))); // Use a slower but simpler function for uncommon cases if (type_of(m) != NORMAL || is_gating(m)) return MoveList(*this).contains(m); // Handle the case where a mandatory piece promotion/demotion is not taken if ( mandatory_piece_promotion() && (is_promoted(from) ? piece_demotion() : promoted_piece_type(type_of(pc)) != NO_PIECE_TYPE) && (promotion_zone_bb(us, promotion_rank(), max_rank()) & (SquareBB[from] | to)) && (!piece_promotion_on_capture() || capture(m))) return false; // Is not a promotion, so promotion piece must be empty if (promotion_type(m) != NO_PIECE_TYPE) return false; // If the 'from' square is not occupied by a piece belonging to the side to // move, the move is obviously not legal. if (pc == NO_PIECE || color_of(pc) != us) return false; // The destination square cannot be occupied by a friendly piece if (pieces(us) & to) return false; // Handle the special case of a pawn move if (type_of(pc) == PAWN) { // We have already handled promotion moves, so destination // cannot be on the 8th/1st rank. if (mandatory_pawn_promotion() && rank_of(to) == relative_rank(us, promotion_rank(), max_rank())) return false; if ( !(attacks_from(from, us) & pieces(~us) & to) // Not a capture && !((from + pawn_push(us) == to) && empty(to)) // Not a single push && !( (from + 2 * pawn_push(us) == to) // Not a double push && (rank_of(from) == relative_rank(us, double_step_rank(), max_rank()) || (first_rank_double_steps() && rank_of(from) == relative_rank(us, RANK_1, max_rank()))) && empty(to) && empty(to - pawn_push(us)) && double_step_enabled())) return false; } else if (!((capture(m) ? attacks_from(us, type_of(pc), from) : moves_from(us, type_of(pc), from)) & to)) return false; // Janggi cannon if (type_of(pc) == JANGGI_CANNON && (pieces(JANGGI_CANNON) & (between_bb(from, to) | to))) return false; // Evasions generator already takes care to avoid some kind of illegal moves // and legal() relies on this. We therefore have to take care that the same // kind of moves are filtered out here. if (checkers() & ~(pieces(CANNON, BANNER) | pieces(HORSE, ELEPHANT) | pieces(JANGGI_CANNON, JANGGI_ELEPHANT))) { if (type_of(pc) != KING) { // Double check? In this case a king move is required if (more_than_one(checkers())) return false; // Our move must be a blocking evasion or a capture of the checking piece Square checksq = lsb(checkers()); if ( !((between_bb(checksq, square(us)) | checkers()) & to) || ((LeaperAttacks[~us][type_of(piece_on(checksq))][checksq] & square(us)) && !(checkers() & to))) return false; } // In case of king moves under check we have to remove king so as to catch // invalid moves like b1a1 when opposite queen is on c1. else if (attackers_to(to, pieces() ^ from, ~us)) return false; } return true; } /// Position::gives_check() tests whether a pseudo-legal move gives a check bool Position::gives_check(Move m) const { assert(is_ok(m)); assert(color_of(moved_piece(m)) == sideToMove); Square from = from_sq(m); Square to = to_sq(m); // No check possible without king if (!count(~sideToMove)) return false; // Is there a direct check? if (type_of(m) != PROMOTION && type_of(m) != PIECE_PROMOTION && type_of(m) != PIECE_DEMOTION) { PieceType pt = type_of(moved_piece(m)); if (AttackRiderTypes[pt] & (HOPPING_RIDERS | ASYMMETRICAL_RIDERS)) { Bitboard occupied = (type_of(m) != DROP ? pieces() ^ from : pieces()) | to; if (attacks_bb(sideToMove, pt, to, occupied) & square(~sideToMove)) return true; } else if (st->checkSquares[pt] & to) return true; } Bitboard janggiCannons = pieces(JANGGI_CANNON); if (type_of(moved_piece(m)) == JANGGI_CANNON) janggiCannons = (type_of(m) == DROP ? janggiCannons : janggiCannons ^ from) | to; else if (janggiCannons & to) janggiCannons ^= to; // Is there a discovered check? if ( ((type_of(m) != DROP && (st->blockersForKing[~sideToMove] & from)) || pieces(sideToMove, CANNON, BANNER) || pieces(HORSE, ELEPHANT) || pieces(JANGGI_CANNON, JANGGI_ELEPHANT)) && attackers_to(square(~sideToMove), (type_of(m) == DROP ? pieces() : pieces() ^ from) | to, sideToMove, janggiCannons)) return true; // Is there a check by gated pieces? if ( is_gating(m) && attacks_bb(sideToMove, gating_type(m), gating_square(m), (pieces() ^ from) | to) & square(~sideToMove)) return true; // Is there a check by special diagonal moves? if (more_than_one(diagonal_lines() & (to | square(~sideToMove)))) { PieceType pt = type_of(moved_piece(m)); PieceType diagType = pt == WAZIR ? FERS : pt == SOLDIER ? PAWN : pt == ROOK ? BISHOP : NO_PIECE_TYPE; Bitboard occupied = type_of(m) == DROP ? pieces() : pieces() ^ from; if (diagType && (attacks_bb(sideToMove, diagType, to, occupied) & square(~sideToMove))) return true; // TODO: fix for longer diagonals else if (pt == JANGGI_CANNON && (attacks_bb(sideToMove, ALFIL, to, occupied) & ~attacks_bb(sideToMove, ELEPHANT, to, occupied) & square(~sideToMove))) return true; } switch (type_of(m)) { case NORMAL: case DROP: case SPECIAL: return false; case PROMOTION: return attacks_bb(sideToMove, promotion_type(m), to, pieces() ^ from) & square(~sideToMove); case PIECE_PROMOTION: return attacks_bb(sideToMove, promoted_piece_type(type_of(moved_piece(m))), to, pieces() ^ from) & square(~sideToMove); case PIECE_DEMOTION: return attacks_bb(sideToMove, type_of(unpromoted_piece_on(from)), to, pieces() ^ from) & square(~sideToMove); // En passant capture with check? We have already handled the case // of direct checks and ordinary discovered check, so the only case we // need to handle is the unusual case of a discovered check through // the captured pawn. case ENPASSANT: { Square capsq = make_square(file_of(to), rank_of(from)); Bitboard b = (pieces() ^ from ^ capsq) | to; return attackers_to(square(~sideToMove), b) & pieces(sideToMove) & b; } case CASTLING: { Square kfrom = from; Square rfrom = to; // Castling is encoded as 'King captures the rook' Square kto = make_square(rfrom > kfrom ? castling_kingside_file() : castling_queenside_file(), castling_rank(sideToMove)); Square rto = kto + (rfrom > kfrom ? WEST : EAST); return (PseudoAttacks[sideToMove][type_of(piece_on(rfrom))][rto] & square(~sideToMove)) && (attacks_bb(sideToMove, type_of(piece_on(rfrom)), rto, (pieces() ^ kfrom ^ rfrom) | rto | kto) & square(~sideToMove)); } default: assert(false); return false; } } /// Position::do_move() makes a move, and saves all information necessary /// to a StateInfo object. The move is assumed to be legal. Pseudo-legal /// moves should be filtered out before this function is called. void Position::do_move(Move m, StateInfo& newSt, bool givesCheck) { assert(is_ok(m)); assert(&newSt != st); thisThread->nodes.fetch_add(1, std::memory_order_relaxed); Key k = st->key ^ Zobrist::side; // Copy some fields of the old state to our new StateInfo object except the // ones which are going to be recalculated from scratch anyway and then switch // our state pointer to point to the new (ready to be updated) state. std::memcpy(static_cast(&newSt), static_cast(st), offsetof(StateInfo, key)); newSt.previous = st; st = &newSt; // Increment ply counters. In particular, rule50 will be reset to zero later on // in case of a capture or a pawn move. ++gamePly; ++st->rule50; ++st->pliesFromNull; if (st->countingLimit) ++st->countingPly; Color us = sideToMove; Color them = ~us; Square from = from_sq(m); Square to = to_sq(m); Piece pc = moved_piece(m); Piece captured = type_of(m) == ENPASSANT ? make_piece(them, PAWN) : piece_on(to); if (to == from) { assert((type_of(m) == PROMOTION && sittuyin_promotion()) || (is_pass(m) && king_pass())); captured = NO_PIECE; } st->capturedpromoted = is_promoted(to); st->unpromotedCapturedPiece = captured ? unpromoted_piece_on(to) : NO_PIECE; st->pass = is_pass(m); assert(color_of(pc) == us); assert(captured == NO_PIECE || color_of(captured) == (type_of(m) != CASTLING ? them : us)); assert(type_of(captured) != KING); if (check_counting() && givesCheck) k ^= Zobrist::checks[us][st->checksRemaining[us]] ^ Zobrist::checks[us][--(st->checksRemaining[us])]; if (type_of(m) == CASTLING) { assert(type_of(pc) != NO_PIECE_TYPE); assert(captured == make_piece(us, castling_rook_piece())); Square rfrom, rto; do_castling(us, from, to, rfrom, rto); k ^= Zobrist::psq[captured][rfrom] ^ Zobrist::psq[captured][rto]; captured = NO_PIECE; } if (captured) { Square capsq = to; // If the captured piece is a pawn, update pawn hash key, otherwise // update non-pawn material. if (type_of(captured) == PAWN) { if (type_of(m) == ENPASSANT) { capsq -= pawn_push(us); assert(pc == make_piece(us, PAWN)); assert(to == st->epSquare); assert(relative_rank(~us, to, max_rank()) == Rank(double_step_rank() + 1)); assert(piece_on(to) == NO_PIECE); assert(piece_on(capsq) == make_piece(them, PAWN)); board[capsq] = NO_PIECE; // Not done by remove_piece() } st->pawnKey ^= Zobrist::psq[captured][capsq]; } else st->nonPawnMaterial[them] -= PieceValue[MG][captured]; // Update board and piece lists bool capturedPromoted = is_promoted(capsq); Piece unpromotedCaptured = unpromoted_piece_on(capsq); remove_piece(captured, capsq); if (captures_to_hand()) { Piece pieceToHand = !capturedPromoted || drop_loop() ? ~captured : unpromotedCaptured ? ~unpromotedCaptured : make_piece(~color_of(captured), PAWN); add_to_hand(pieceToHand); k ^= Zobrist::inHand[pieceToHand][pieceCountInHand[color_of(pieceToHand)][type_of(pieceToHand)] - 1] ^ Zobrist::inHand[pieceToHand][pieceCountInHand[color_of(pieceToHand)][type_of(pieceToHand)]]; } // Update material hash key and prefetch access to materialTable k ^= Zobrist::psq[captured][capsq]; st->materialKey ^= Zobrist::psq[captured][pieceCount[captured]]; prefetch(thisThread->materialTable[st->materialKey]); // Reset rule 50 counter st->rule50 = 0; } // Update hash key if (type_of(m) == DROP) { Piece pc_hand = make_piece(us, in_hand_piece_type(m)); k ^= Zobrist::psq[pc][to] ^ Zobrist::inHand[pc_hand][pieceCountInHand[color_of(pc_hand)][type_of(pc_hand)] - 1] ^ Zobrist::inHand[pc_hand][pieceCountInHand[color_of(pc_hand)][type_of(pc_hand)]]; } else k ^= Zobrist::psq[pc][from] ^ Zobrist::psq[pc][to]; // Reset en passant square if (st->epSquare != SQ_NONE) { k ^= Zobrist::enpassant[file_of(st->epSquare)]; st->epSquare = SQ_NONE; } // Update castling rights if needed if (type_of(m) != DROP && st->castlingRights && (castlingRightsMask[from] | castlingRightsMask[to])) { int cr = castlingRightsMask[from] | castlingRightsMask[to]; k ^= Zobrist::castling[st->castlingRights & cr]; st->castlingRights &= ~cr; } // Move the piece. The tricky Chess960 castling is handled earlier if (type_of(m) == DROP) { drop_piece(make_piece(us, in_hand_piece_type(m)), pc, to); st->materialKey ^= Zobrist::psq[pc][pieceCount[pc]-1]; if (type_of(pc) != PAWN) st->nonPawnMaterial[us] += PieceValue[MG][pc]; // Set castling rights for dropped king or rook if (castling_dropped_piece() && rank_of(to) == castling_rank(us)) { if (type_of(pc) == KING && file_of(to) == FILE_E) { Bitboard castling_rooks = pieces(us, castling_rook_piece()) & rank_bb(castling_rank(us)) & (file_bb(FILE_A) | file_bb(max_file())); while (castling_rooks) set_castling_right(us, pop_lsb(&castling_rooks)); } else if (type_of(pc) == castling_rook_piece()) { if ( (file_of(to) == FILE_A || file_of(to) == max_file()) && piece_on(make_square(FILE_E, castling_rank(us))) == make_piece(us, KING)) set_castling_right(us, to); } } } else if (type_of(m) != CASTLING) move_piece(pc, from, to); // If the moving piece is a pawn do some special extra work if (type_of(pc) == PAWN) { // Set en-passant square if the moved pawn can be captured if ( std::abs(int(to) - int(from)) == 2 * NORTH && relative_rank(us, rank_of(from), max_rank()) == double_step_rank() && (attacks_from(to - pawn_push(us), us) & pieces(them, PAWN))) { st->epSquare = to - pawn_push(us); k ^= Zobrist::enpassant[file_of(st->epSquare)]; } else if (type_of(m) == PROMOTION || type_of(m) == PIECE_PROMOTION) { Piece promotion = make_piece(us, type_of(m) == PROMOTION ? promotion_type(m) : promoted_piece_type(PAWN)); assert(relative_rank(us, to, max_rank()) >= promotion_rank() || sittuyin_promotion()); assert(type_of(promotion) >= KNIGHT && type_of(promotion) < KING); remove_piece(pc, to); put_piece(promotion, to, true, type_of(m) == PIECE_PROMOTION ? pc : NO_PIECE); // Update hash keys k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to]; st->pawnKey ^= Zobrist::psq[pc][to]; st->materialKey ^= Zobrist::psq[promotion][pieceCount[promotion]-1] ^ Zobrist::psq[pc][pieceCount[pc]]; // Update material st->nonPawnMaterial[us] += PieceValue[MG][promotion]; } // Update pawn hash key st->pawnKey ^= (type_of(m) != DROP ? Zobrist::psq[pc][from] : 0) ^ Zobrist::psq[pc][to]; // Reset rule 50 draw counter st->rule50 = 0; } else if (type_of(m) == PIECE_PROMOTION) { Piece promotion = make_piece(us, promoted_piece_type(type_of(pc))); remove_piece(pc, to); put_piece(promotion, to, true, pc); // Update hash keys k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[promotion][to]; st->materialKey ^= Zobrist::psq[promotion][pieceCount[promotion]-1] ^ Zobrist::psq[pc][pieceCount[pc]]; // Update material st->nonPawnMaterial[us] += PieceValue[MG][promotion] - PieceValue[MG][pc]; } else if (type_of(m) == PIECE_DEMOTION) { Piece demotion = unpromoted_piece_on(to); remove_piece(pc, to); put_piece(demotion, to); // Update hash keys k ^= Zobrist::psq[pc][to] ^ Zobrist::psq[demotion][to]; st->materialKey ^= Zobrist::psq[demotion][pieceCount[demotion]-1] ^ Zobrist::psq[pc][pieceCount[pc]]; // Update material st->nonPawnMaterial[us] += PieceValue[MG][demotion] - PieceValue[MG][pc]; } // Set capture piece st->capturedPiece = captured; // Add gating piece if (is_gating(m)) { Square gate = gating_square(m); Piece gating_piece = make_piece(us, gating_type(m)); put_piece(gating_piece, gate); remove_from_hand(gating_piece); st->gatesBB[us] ^= gate; k ^= Zobrist::psq[gating_piece][gate]; st->materialKey ^= Zobrist::psq[gating_piece][pieceCount[gating_piece]]; st->nonPawnMaterial[us] += PieceValue[MG][gating_piece]; } // Remove gates if (gating()) { if (is_ok(from) && (gates(us) & from)) st->gatesBB[us] ^= from; if (type_of(m) == CASTLING && (gates(us) & to_sq(m))) st->gatesBB[us] ^= to_sq(m); if (gates(them) & to) st->gatesBB[them] ^= to; if (seirawan_gating() && !count_in_hand(us, ALL_PIECES) && !captures_to_hand()) st->gatesBB[us] = 0; } // Update the key with the final value st->key = k; // Calculate checkers bitboard (if move gives check) st->checkersBB = givesCheck ? attackers_to(square(them), us) & pieces(us) : Bitboard(0); sideToMove = ~sideToMove; if ( counting_rule() && (!st->countingLimit || (captured && count(sideToMove) == 1)) && counting_limit()) { st->countingLimit = 2 * counting_limit(); st->countingPly = counting_rule() == MAKRUK_COUNTING && count(sideToMove) == 1 ? 2 * count() : 0; } // Update king attacks used for fast check detection set_check_info(st); // Calculate the repetition info. It is the ply distance from the previous // occurrence of the same position, negative in the 3-fold case, or zero // if the position was not repeated. st->repetition = 0; int end = captures_to_hand() ? st->pliesFromNull : std::min(st->rule50, st->pliesFromNull); if (end >= 4) { StateInfo* stp = st->previous->previous; for (int i = 4; i <= end; i += 2) { stp = stp->previous->previous; if (stp->key == st->key) { st->repetition = stp->repetition ? -i : i; break; } } } assert(pos_is_ok()); } /// Position::undo_move() unmakes a move. When it returns, the position should /// be restored to exactly the same state as before the move was made. void Position::undo_move(Move m) { assert(is_ok(m)); sideToMove = ~sideToMove; Color us = sideToMove; Square from = from_sq(m); Square to = to_sq(m); Piece pc = piece_on(to); assert(type_of(m) == DROP || empty(from) || type_of(m) == CASTLING || is_gating(m) || (type_of(m) == PROMOTION && sittuyin_promotion()) || (is_pass(m) && king_pass())); assert(type_of(st->capturedPiece) != KING); // Remove gated piece if (is_gating(m)) { Piece gating_piece = make_piece(us, gating_type(m)); remove_piece(gating_piece, gating_square(m)); add_to_hand(gating_piece); st->gatesBB[us] |= gating_square(m); } if (type_of(m) == PROMOTION) { assert(relative_rank(us, to, max_rank()) >= promotion_rank() || sittuyin_promotion()); assert(type_of(pc) == promotion_type(m)); assert(type_of(pc) >= KNIGHT && type_of(pc) < KING); remove_piece(pc, to); pc = make_piece(us, PAWN); put_piece(pc, to); } else if (type_of(m) == PIECE_PROMOTION) { Piece unpromotedPiece = unpromoted_piece_on(to); remove_piece(pc, to); pc = unpromotedPiece; put_piece(pc, to); } else if (type_of(m) == PIECE_DEMOTION) { remove_piece(pc, to); Piece unpromotedPc = pc; pc = make_piece(us, promoted_piece_type(type_of(pc))); put_piece(pc, to, true, unpromotedPc); } if (type_of(m) == CASTLING) { Square rfrom, rto; do_castling(us, from, to, rfrom, rto); } else { if (type_of(m) == DROP) undrop_piece(make_piece(us, in_hand_piece_type(m)), pc, to); // Remove the dropped piece else move_piece(pc, to, from); // Put the piece back at the source square if (st->capturedPiece) { Square capsq = to; if (type_of(m) == ENPASSANT) { capsq -= pawn_push(us); assert(type_of(pc) == PAWN); assert(to == st->previous->epSquare); assert(relative_rank(~us, to, max_rank()) == Rank(double_step_rank() + 1)); assert(piece_on(capsq) == NO_PIECE); assert(st->capturedPiece == make_piece(~us, PAWN)); } put_piece(st->capturedPiece, capsq, st->capturedpromoted, st->unpromotedCapturedPiece); // Restore the captured piece if (captures_to_hand()) remove_from_hand(!drop_loop() && st->capturedpromoted ? (st->unpromotedCapturedPiece ? ~st->unpromotedCapturedPiece : make_piece(~color_of(st->capturedPiece), PAWN)) : ~st->capturedPiece); } } // Finally point our state pointer back to the previous state st = st->previous; --gamePly; assert(pos_is_ok()); } /// Position::do_castling() is a helper used to do/undo a castling move. This /// is a bit tricky in Chess960 where from/to squares can overlap. template void Position::do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto) { bool kingSide = to > from; rfrom = to; // Castling is encoded as "king captures friendly rook" to = make_square(kingSide ? castling_kingside_file() : castling_queenside_file(), castling_rank(us)); rto = to + (kingSide ? WEST : EAST); // Remove both pieces first since squares could overlap in Chess960 Piece castlingKingPiece = piece_on(Do ? from : to); Piece castlingRookPiece = piece_on(Do ? rfrom : rto); remove_piece(castlingKingPiece, Do ? from : to); remove_piece(castlingRookPiece, Do ? rfrom : rto); board[Do ? from : to] = board[Do ? rfrom : rto] = NO_PIECE; // Since remove_piece doesn't do it for us put_piece(castlingKingPiece, Do ? to : from); put_piece(castlingRookPiece, Do ? rto : rfrom); } /// Position::do(undo)_null_move() is used to do(undo) a "null move": it flips /// the side to move without executing any move on the board. void Position::do_null_move(StateInfo& newSt) { assert(!checkers()); assert(&newSt != st); std::memcpy(&newSt, st, sizeof(StateInfo)); newSt.previous = st; st = &newSt; if (st->epSquare != SQ_NONE) { st->key ^= Zobrist::enpassant[file_of(st->epSquare)]; st->epSquare = SQ_NONE; } st->key ^= Zobrist::side; prefetch(TT.first_entry(st->key)); ++st->rule50; st->pliesFromNull = 0; sideToMove = ~sideToMove; set_check_info(st); st->repetition = 0; assert(pos_is_ok()); } void Position::undo_null_move() { assert(!checkers()); st = st->previous; sideToMove = ~sideToMove; } /// Position::key_after() computes the new hash key after the given move. Needed /// for speculative prefetch. It doesn't recognize special moves like castling, /// en-passant and promotions. Key Position::key_after(Move m) const { Square from = from_sq(m); Square to = to_sq(m); Piece pc = moved_piece(m); Piece captured = piece_on(to); Key k = st->key ^ Zobrist::side; if (captured) { k ^= Zobrist::psq[captured][to]; if (captures_to_hand()) { Piece removeFromHand = !drop_loop() && is_promoted(to) ? make_piece(~color_of(captured), PAWN) : ~captured; k ^= Zobrist::inHand[removeFromHand][pieceCountInHand[color_of(removeFromHand)][type_of(removeFromHand)] + 1] ^ Zobrist::inHand[removeFromHand][pieceCountInHand[color_of(removeFromHand)][type_of(removeFromHand)]]; } } if (type_of(m) == DROP) { Piece pc_hand = make_piece(sideToMove, in_hand_piece_type(m)); return k ^ Zobrist::psq[pc][to] ^ Zobrist::inHand[pc_hand][pieceCountInHand[color_of(pc_hand)][type_of(pc_hand)]] ^ Zobrist::inHand[pc_hand][pieceCountInHand[color_of(pc_hand)][type_of(pc_hand)] - 1]; } return k ^ Zobrist::psq[pc][to] ^ Zobrist::psq[pc][from]; } /// Position::see_ge (Static Exchange Evaluation Greater or Equal) tests if the /// SEE value of move is greater or equal to the given threshold. We'll use an /// algorithm similar to alpha-beta pruning with a null window. bool Position::see_ge(Move m, Value threshold) const { assert(is_ok(m)); // Only deal with normal moves, assume others pass a simple see if (type_of(m) != NORMAL && type_of(m) != DROP && type_of(m) != PIECE_PROMOTION) return VALUE_ZERO >= threshold; Square from = from_sq(m), to = to_sq(m); // nCheck if (check_counting() && color_of(moved_piece(m)) == sideToMove && gives_check(m)) return true; // Extinction if ( extinction_value() != VALUE_NONE && piece_on(to) && ( ( extinction_piece_types().find(type_of(piece_on(to))) != extinction_piece_types().end() && pieceCount[piece_on(to)] == extinction_piece_count() + 1) || ( extinction_piece_types().find(ALL_PIECES) != extinction_piece_types().end() && count(~sideToMove) == extinction_piece_count() + 1))) return extinction_value() < VALUE_ZERO; int swap = PieceValue[MG][piece_on(to)] - threshold; if (swap < 0) return false; swap = PieceValue[MG][moved_piece(m)] - swap; if (swap <= 0) return true; Bitboard occupied = (type_of(m) != DROP ? pieces() ^ from : pieces()) ^ to; Color stm = color_of(moved_piece(m)); Bitboard attackers = attackers_to(to, occupied); Bitboard stmAttackers, bb; int res = 1; // Flying general rule if (var->flyingGeneral) { if (attackers & pieces(stm, KING)) attackers |= attacks_bb(stm, ROOK, to, occupied & ~pieces(ROOK)) & pieces(~stm, KING); if (attackers & pieces(~stm, KING)) attackers |= attacks_bb(~stm, ROOK, to, occupied & ~pieces(ROOK)) & pieces(stm, KING); } // Janggi cannons can not capture each other if (type_of(moved_piece(m)) == JANGGI_CANNON && !(attackers & pieces(~stm) & ~pieces(JANGGI_CANNON))) attackers &= ~pieces(~stm, JANGGI_CANNON); while (true) { stm = ~stm; attackers &= occupied; // If stm has no more attackers then give up: stm loses if (!(stmAttackers = attackers & pieces(stm))) break; // Don't allow pinned pieces to attack (except the king) as long as // there are pinners on their original square. if (st->pinners[~stm] & occupied) stmAttackers &= ~st->blockersForKing[stm]; if (!stmAttackers) break; res ^= 1; // Locate and remove the next least valuable attacker, and add to // the bitboard 'attackers' any X-ray attackers behind it. if ((bb = stmAttackers & pieces(PAWN))) { if ((swap = PawnValueMg - swap) < res) break; occupied ^= lsb(bb); attackers |= attacks_bb(to, occupied) & pieces(BISHOP, QUEEN); } else if ((bb = stmAttackers & pieces(KNIGHT))) { if ((swap = KnightValueMg - swap) < res) break; occupied ^= lsb(bb); } else if ((bb = stmAttackers & pieces(BISHOP))) { if ((swap = BishopValueMg - swap) < res) break; occupied ^= lsb(bb); attackers |= attacks_bb(to, occupied) & pieces(BISHOP, QUEEN); } else if ((bb = stmAttackers & pieces(ROOK))) { if ((swap = RookValueMg - swap) < res) break; occupied ^= lsb(bb); attackers |= attacks_bb(to, occupied) & pieces(ROOK, QUEEN); } else if ((bb = stmAttackers & pieces(QUEEN))) { if ((swap = QueenValueMg - swap) < res) break; occupied ^= lsb(bb); attackers |= (attacks_bb(to, occupied) & pieces(BISHOP, QUEEN)) | (attacks_bb(to, occupied) & pieces(ROOK , QUEEN)); } // fairy pieces // pick next piece without considering value else if ((bb = stmAttackers & ~pieces(KING))) { if ((swap = PieceValue[MG][piece_on(lsb(bb))] - swap) < res) break; occupied ^= lsb(bb); } else // KING // If we "capture" with the king but opponent still has attackers, // reverse the result. return (attackers & ~pieces(stm)) ? res ^ 1 : res; } return bool(res); } /// Position::is_optinal_game_end() tests whether the position may end the game by /// 50-move rule, by repetition, or a variant rule that allows a player to claim a game result. bool Position::is_optional_game_end(Value& result, int ply, int countStarted) const { // n-move rule if (n_move_rule() && st->rule50 > (2 * n_move_rule() - 1) && (!checkers() || MoveList(*this).size())) { result = var->materialCounting ? convert_mate_value(material_counting_result(), ply) : VALUE_DRAW; return true; } // n-fold repetition if (n_fold_rule()) { int end = captures_to_hand() ? st->pliesFromNull : std::min(st->rule50, st->pliesFromNull); if (end >= 4) { StateInfo* stp = st->previous->previous; int cnt = 0; bool perpetualThem = st->checkersBB && stp->checkersBB; bool perpetualUs = st->previous->checkersBB && stp->previous->checkersBB; for (int i = 4; i <= end; i += 2) { stp = stp->previous->previous; perpetualThem &= bool(stp->checkersBB); // Return a draw score if a position repeats once earlier but strictly // after the root, or repeats twice before or at the root. if ( stp->key == st->key && ++cnt + 1 == (ply > i ? 2 : n_fold_rule())) { result = convert_mate_value( var->perpetualCheckIllegal && perpetualThem ? VALUE_MATE : var->perpetualCheckIllegal && perpetualUs ? -VALUE_MATE : var->nFoldValueAbsolute && sideToMove == BLACK ? -var->nFoldValue : var->nFoldValue, ply); if (result == VALUE_DRAW && var->materialCounting) result = convert_mate_value(material_counting_result(), ply); return true; } if (i + 1 <= end) perpetualUs &= bool(stp->previous->checkersBB); } } } // counting rules if ( counting_rule() && st->countingLimit && counting_ply(countStarted) > st->countingLimit && (!checkers() || MoveList(*this).size())) { result = VALUE_DRAW; return true; } // sittuyin stalemate due to optional promotion (3.9 c.7) if ( sittuyin_promotion() && count(sideToMove) == 2 && count(sideToMove) == 1 && !checkers()) { bool promotionsOnly = true; for (const auto& m : MoveList(*this)) if (type_of(m) != PROMOTION) { promotionsOnly = false; break; } if (promotionsOnly) { result = VALUE_DRAW; return true; } } return false; } /// Position::is_immediate_game_end() tests whether the position ends the game /// immediately by a variant rule, i.e., there are no more legal moves. /// It does not not detect stalemates. bool Position::is_immediate_game_end(Value& result, int ply) const { // extinction if (extinction_value() != VALUE_NONE) { for (Color c : { WHITE, BLACK }) for (PieceType pt : extinction_piece_types()) if ( count_with_hand( c, pt) <= var->extinctionPieceCount && count_with_hand(~c, pt) >= var->extinctionOpponentPieceCount + (extinction_claim() && c == sideToMove)) { result = c == sideToMove ? extinction_value(ply) : -extinction_value(ply); return true; } } // capture the flag if ( capture_the_flag_piece() && !flag_move() && (capture_the_flag(~sideToMove) & pieces(~sideToMove, capture_the_flag_piece()))) { result = mated_in(ply); return true; } if ( capture_the_flag_piece() && flag_move() && (capture_the_flag(sideToMove) & pieces(sideToMove, capture_the_flag_piece()))) { result = (capture_the_flag(~sideToMove) & pieces(~sideToMove, capture_the_flag_piece())) && sideToMove == WHITE ? VALUE_DRAW : mate_in(ply); return true; } // nCheck if (check_counting() && checks_remaining(~sideToMove) == 0) { result = mated_in(ply); return true; } // Connect-n if (connect_n() > 0) { Bitboard b; for (Direction d : {NORTH, NORTH_EAST, EAST, SOUTH_EAST}) { b = pieces(~sideToMove); for (int i = 1; i < connect_n() && b; i++) b &= shift(d, b); if (b) { result = mated_in(ply); return true; } } } // Check for bikjang rule (Janggi) and double passing if (st->pliesFromNull > 0 && ((st->bikjang && st->previous->bikjang) || (st->pass && st->previous->pass))) { result = var->materialCounting ? convert_mate_value(material_counting_result(), ply) : VALUE_DRAW; return true; } // Tsume mode: Assume that side with king wins when not in check if (!count(~sideToMove) && count(sideToMove) && !checkers() && Options["TsumeMode"]) { result = mate_in(ply); return true; } return false; } // Position::has_repeated() tests whether there has been at least one repetition // of positions since the last capture or pawn move. bool Position::has_repeated() const { StateInfo* stc = st; int end = captures_to_hand() ? st->pliesFromNull : std::min(st->rule50, st->pliesFromNull); while (end-- >= 4) { if (stc->repetition) return true; stc = stc->previous; } return false; } /// Position::has_game_cycle() tests if the position has a move which draws by repetition, /// or an earlier position has a move that directly reaches the current position. bool Position::has_game_cycle(int ply) const { int j; int end = captures_to_hand() ? st->pliesFromNull : std::min(st->rule50, st->pliesFromNull); if (end < 3 || var->nFoldValue != VALUE_DRAW || var->perpetualCheckIllegal || var->materialCounting) return false; Key originalKey = st->key; StateInfo* stp = st->previous; for (int i = 3; i <= end; i += 2) { stp = stp->previous->previous; Key moveKey = originalKey ^ stp->key; if ( (j = H1(moveKey), cuckoo[j] == moveKey) || (j = H2(moveKey), cuckoo[j] == moveKey)) { Move move = cuckooMove[j]; Square s1 = from_sq(move); Square s2 = to_sq(move); if (!(between_bb(s1, s2) & pieces())) { if (ply > i) return true; // For nodes before or at the root, check that the move is a // repetition rather than a move to the current position. // In the cuckoo table, both moves Rc1c5 and Rc5c1 are stored in // the same location, so we have to select which square to check. if (color_of(piece_on(empty(s1) ? s2 : s1)) != side_to_move()) continue; // For repetitions before or at the root, require one more if (stp->repetition) return true; } } } return false; } /// Position::counting_limit() returns the counting limit in full moves. int Position::counting_limit() const { assert(counting_rule()); switch (counting_rule()) { case MAKRUK_COUNTING: // No counting for side to move if (count() || count(~sideToMove) == 1) return 0; // Board's honor rule if (count(sideToMove) > 1) return 64; // Pieces' honor rule if (count(~sideToMove) > 1) return 8; if (count(~sideToMove) == 1) return 16; if (count(~sideToMove) > 1) return 22; if (count(~sideToMove) > 1) return 32; if (count(~sideToMove) == 1) return 44; return 64; case ASEAN_COUNTING: if (count(sideToMove) > 1) return 0; if (count(~sideToMove)) return 16; if (count(~sideToMove) && count(~sideToMove)) return 44; if (count(~sideToMove) && count(~sideToMove)) return 64; return 0; default: assert(false); return 0; } } /// Position::flip() flips position with the white and black sides reversed. This /// is only useful for debugging e.g. for finding evaluation symmetry bugs. void Position::flip() { string f, token; std::stringstream ss(fen()); for (Rank r = max_rank(); r >= RANK_1; --r) // Piece placement { std::getline(ss, token, r > RANK_1 ? '/' : ' '); f.insert(0, token + (f.empty() ? " " : "/")); } ss >> token; // Active color f += (token == "w" ? "B " : "W "); // Will be lowercased later ss >> token; // Castling availability f += token + " "; std::transform(f.begin(), f.end(), f.begin(), [](char c) { return char(islower(c) ? toupper(c) : tolower(c)); }); ss >> token; // En passant square f += (token == "-" ? token : token.replace(1, 1, token[1] == '3' ? "6" : "3")); std::getline(ss, token); // Half and full moves f += token; set(variant(), f, is_chess960(), st, this_thread()); assert(pos_is_ok()); } /// Position::pos_is_ok() performs some consistency checks for the /// position object and raises an asserts if something wrong is detected. /// This is meant to be helpful when debugging. bool Position::pos_is_ok() const { constexpr bool Fast = true; // Quick (default) or full check? if ( (sideToMove != WHITE && sideToMove != BLACK) || (count(WHITE) && piece_on(square(WHITE)) != make_piece(WHITE, KING)) || (count(BLACK) && piece_on(square(BLACK)) != make_piece(BLACK, KING)) || ( ep_square() != SQ_NONE && relative_rank(~sideToMove, ep_square(), max_rank()) != Rank(double_step_rank() + 1))) assert(0 && "pos_is_ok: Default"); if (Fast) return true; if ( pieceCount[make_piece(~sideToMove, KING)] && (attackers_to(square(~sideToMove)) & pieces(sideToMove))) assert(0 && "pos_is_ok: Kings"); if ( pieceCount[make_piece(WHITE, PAWN)] > 64 || pieceCount[make_piece(BLACK, PAWN)] > 64) assert(0 && "pos_is_ok: Pawns"); if ( (pieces(WHITE) & pieces(BLACK)) || (pieces(WHITE) | pieces(BLACK)) != pieces() || popcount(pieces(WHITE)) > 64 || popcount(pieces(BLACK)) > 64) assert(0 && "pos_is_ok: Bitboards"); for (PieceType p1 = PAWN; p1 <= KING; ++p1) for (PieceType p2 = PAWN; p2 <= KING; ++p2) if (p1 != p2 && (pieces(p1) & pieces(p2))) assert(0 && "pos_is_ok: Bitboards"); StateInfo si = *st; set_state(&si); if (std::memcmp(&si, st, sizeof(StateInfo))) assert(0 && "pos_is_ok: State"); for (Color c : {WHITE, BLACK}) for (PieceType pt = PAWN; pt <= KING; ++pt) { Piece pc = make_piece(c, pt); if ( pieceCount[pc] != popcount(pieces(c, pt)) || pieceCount[pc] != std::count(board, board + SQUARE_NB, pc)) assert(0 && "pos_is_ok: Pieces"); for (int i = 0; i < pieceCount[pc]; ++i) if (board[pieceList[pc][i]] != pc || index[pieceList[pc][i]] != i) assert(0 && "pos_is_ok: Index"); } for (Color c : { WHITE, BLACK }) for (CastlingRights cr : {c & KING_SIDE, c & QUEEN_SIDE}) { if (!can_castle(cr)) continue; if ( piece_on(castlingRookSquare[cr]) != make_piece(c, castling_rook_piece()) || castlingRightsMask[castlingRookSquare[cr]] != cr || (count(c) && (castlingRightsMask[square(c)] & cr) != cr)) assert(0 && "pos_is_ok: Castling"); } return true; } Fairy-Stockfish-fairy_sf_11_1/src/position.h000066400000000000000000001020021366242550200212100ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef POSITION_H_INCLUDED #define POSITION_H_INCLUDED #include #include #include // For std::unique_ptr #include #include #include "bitboard.h" #include "types.h" #include "variant.h" /// StateInfo struct stores information needed to restore a Position object to /// its previous state when we retract a move. Whenever a move is made on the /// board (by calling Position::do_move), a StateInfo object must be passed. struct StateInfo { // Copied when making a move Key pawnKey; Key materialKey; Value nonPawnMaterial[COLOR_NB]; int castlingRights; int rule50; int pliesFromNull; int countingPly; int countingLimit; CheckCount checksRemaining[COLOR_NB]; Square epSquare; Bitboard gatesBB[COLOR_NB]; // Not copied when making a move (will be recomputed anyhow) Key key; Bitboard checkersBB; Piece capturedPiece; Piece unpromotedCapturedPiece; StateInfo* previous; Bitboard blockersForKing[COLOR_NB]; Bitboard pinners[COLOR_NB]; Bitboard checkSquares[PIECE_TYPE_NB]; bool capturedpromoted; bool shak; bool bikjang; bool pass; int repetition; }; /// A list to keep track of the position states along the setup moves (from the /// start position to the position just before the search starts). Needed by /// 'draw by repetition' detection. Use a std::deque because pointers to /// elements are not invalidated upon list resizing. typedef std::unique_ptr> StateListPtr; /// Position class stores information regarding the board representation as /// pieces, side to move, hash keys, castling info, etc. Important methods are /// do_move() and undo_move(), used by the search to update node info when /// traversing the search tree. class Thread; class Position { public: static void init(); Position() = default; Position(const Position&) = delete; Position& operator=(const Position&) = delete; // FEN string input/output Position& set(const Variant* v, const std::string& fenStr, bool isChess960, StateInfo* si, Thread* th, bool sfen = false); Position& set(const std::string& code, Color c, StateInfo* si); const std::string fen(bool sfen = false, bool showPromoted = false, int countStarted = 0, std::string holdings = "-") const; // Variant rule properties const Variant* variant() const; Rank max_rank() const; File max_file() const; bool two_boards() const; Bitboard board_bb() const; Bitboard board_bb(Color c, PieceType pt) const; const std::set& piece_types() const; const std::string& piece_to_char() const; const std::string& piece_to_char_synonyms() const; Rank promotion_rank() const; const std::set >& promotion_piece_types() const; bool sittuyin_promotion() const; int promotion_limit(PieceType pt) const; PieceType promoted_piece_type(PieceType pt) const; bool piece_promotion_on_capture() const; bool mandatory_pawn_promotion() const; bool mandatory_piece_promotion() const; bool piece_demotion() const; bool endgame_eval() const; bool double_step_enabled() const; Rank double_step_rank() const; bool first_rank_double_steps() const; bool castling_enabled() const; bool castling_dropped_piece() const; File castling_kingside_file() const; File castling_queenside_file() const; Rank castling_rank(Color c) const; PieceType castling_rook_piece() const; PieceType king_type() const; bool checking_permitted() const; bool drop_checks() const; bool must_capture() const; bool must_drop() const; bool piece_drops() const; bool drop_loop() const; bool captures_to_hand() const; bool first_rank_pawn_drops() const; bool drop_on_top() const; Bitboard drop_region(Color c) const; Bitboard drop_region(Color c, PieceType pt) const; bool sittuyin_rook_drop() const; bool drop_opposite_colored_bishop() const; bool drop_promoted() const; bool shogi_doubled_pawn() const; bool immobility_illegal() const; bool gating() const; bool seirawan_gating() const; bool cambodian_moves() const; Bitboard diagonal_lines() const; bool king_pass() const; bool king_pass_on_stalemate() const; Bitboard promoted_soldiers(Color c) const; bool makpong() const; // winning conditions int n_move_rule() const; int n_fold_rule() const; Value stalemate_value(int ply = 0) const; Value checkmate_value(int ply = 0) const; Value extinction_value(int ply = 0) const; bool extinction_claim() const; const std::set& extinction_piece_types() const; int extinction_piece_count() const; int extinction_opponent_piece_count() const; PieceType capture_the_flag_piece() const; Bitboard capture_the_flag(Color c) const; bool flag_move() const; bool check_counting() const; int connect_n() const; CheckCount checks_remaining(Color c) const; MaterialCounting material_counting() const; CountingRule counting_rule() const; // Variant-specific properties int count_in_hand(Color c, PieceType pt) const; int count_with_hand(Color c, PieceType pt) const; bool bikjang() const; // Position representation Bitboard pieces() const; Bitboard pieces(PieceType pt) const; Bitboard pieces(PieceType pt1, PieceType pt2) const; Bitboard pieces(Color c) const; Bitboard pieces(Color c, PieceType pt) const; Bitboard pieces(Color c, PieceType pt1, PieceType pt2) const; Bitboard major_pieces(Color c) const; Piece piece_on(Square s) const; Piece unpromoted_piece_on(Square s) const; Square ep_square() const; Bitboard gates(Color c) const; bool empty(Square s) const; int count(Color c, PieceType pt) const; template int count(Color c) const; template int count() const; template const Square* squares(Color c) const; const Square* squares(Color c, PieceType pt) const; template Square square(Color c) const; bool is_on_semiopen_file(Color c, Square s) const; // Castling int castling_rights(Color c) const; bool can_castle(CastlingRights cr) const; bool castling_impeded(CastlingRights cr) const; Square castling_rook_square(CastlingRights cr) const; // Checking Bitboard checkers() const; Bitboard blockers_for_king(Color c) const; Bitboard check_squares(PieceType pt) const; bool is_discovery_check_on_king(Color c, Move m) const; // Attacks to/from a given square Bitboard attackers_to(Square s) const; Bitboard attackers_to(Square s, Color c) const; Bitboard attackers_to(Square s, Bitboard occupied) const; Bitboard attackers_to(Square s, Bitboard occupied, Color c) const; Bitboard attackers_to(Square s, Bitboard occupied, Color c, Bitboard janggiCannons) const; Bitboard attacks_from(Color c, PieceType pt, Square s) const; template Bitboard attacks_from(Square s, Color c) const; Bitboard moves_from(Color c, PieceType pt, Square s) const; Bitboard slider_blockers(Bitboard sliders, Square s, Bitboard& pinners, Color c) const; // Properties of moves bool legal(Move m) const; bool pseudo_legal(const Move m) const; bool capture(Move m) const; bool capture_or_promotion(Move m) const; bool gives_check(Move m) const; bool advanced_pawn_push(Move m) const; Piece moved_piece(Move m) const; Piece captured_piece() const; // Piece specific bool pawn_passed(Color c, Square s) const; bool opposite_bishops() const; bool is_promoted(Square s) const; int pawns_on_same_color_squares(Color c, Square s) const; // Doing and undoing moves void do_move(Move m, StateInfo& newSt); void do_move(Move m, StateInfo& newSt, bool givesCheck); void undo_move(Move m); void do_null_move(StateInfo& newSt); void undo_null_move(); // Static Exchange Evaluation bool see_ge(Move m, Value threshold = VALUE_ZERO) const; // Accessing hash keys Key key() const; Key key_after(Move m) const; Key material_key() const; Key pawn_key() const; // Other properties of the position Color side_to_move() const; int game_ply() const; bool is_chess960() const; Thread* this_thread() const; bool is_immediate_game_end() const; bool is_game_end(Value& result, int ply = 0) const; bool is_optional_game_end(Value& result, int ply = 0, int countStarted = 0) const; bool is_immediate_game_end(Value& result, int ply = 0) const; Value material_counting_result() const; bool has_game_cycle(int ply) const; bool has_repeated() const; int counting_limit() const; int counting_ply(int countStarted) const; int rule50_count() const; Score psq_score() const; Value non_pawn_material(Color c) const; Value non_pawn_material() const; // Position consistency check, for debugging bool pos_is_ok() const; void flip(); private: // Initialization helpers (used while setting up a position) void set_castling_right(Color c, Square rfrom); void set_state(StateInfo* si) const; void set_check_info(StateInfo* si) const; // Other helpers void put_piece(Piece pc, Square s, bool isPromoted = false, Piece unpromotedPc = NO_PIECE); void remove_piece(Piece pc, Square s); void move_piece(Piece pc, Square from, Square to); template void do_castling(Color us, Square from, Square& to, Square& rfrom, Square& rto); // Data members Piece board[SQUARE_NB]; Piece unpromotedBoard[SQUARE_NB]; Bitboard byTypeBB[PIECE_TYPE_NB]; Bitboard byColorBB[COLOR_NB]; int pieceCount[PIECE_NB]; Square pieceList[PIECE_NB][64]; int index[SQUARE_NB]; int castlingRightsMask[SQUARE_NB]; Square castlingRookSquare[CASTLING_RIGHT_NB]; Bitboard castlingPath[CASTLING_RIGHT_NB]; int gamePly; Color sideToMove; Score psq; Thread* thisThread; StateInfo* st; // variant-specific const Variant* var; bool chess960; int pieceCountInHand[COLOR_NB][PIECE_TYPE_NB]; Bitboard promotedPieces; void add_to_hand(Piece pc); void remove_from_hand(Piece pc); void drop_piece(Piece pc_hand, Piece pc_drop, Square s); void undrop_piece(Piece pc_hand, Piece pc_drop, Square s); }; namespace PSQT { extern Score psq[PIECE_NB][SQUARE_NB + 1]; } extern std::ostream& operator<<(std::ostream& os, const Position& pos); inline const Variant* Position::variant() const { assert(var != nullptr); return var; } inline Rank Position::max_rank() const { assert(var != nullptr); return var->maxRank; } inline File Position::max_file() const { assert(var != nullptr); return var->maxFile; } inline bool Position::two_boards() const { assert(var != nullptr); return var->twoBoards; } inline Bitboard Position::board_bb() const { assert(var != nullptr); return board_size_bb(var->maxFile, var->maxRank); } inline Bitboard Position::board_bb(Color c, PieceType pt) const { assert(var != nullptr); return var->mobilityRegion[c][pt] ? var->mobilityRegion[c][pt] & board_bb() : board_bb(); } inline const std::set& Position::piece_types() const { assert(var != nullptr); return var->pieceTypes; } inline const std::string& Position::piece_to_char() const { assert(var != nullptr); return var->pieceToChar; } inline const std::string& Position::piece_to_char_synonyms() const { assert(var != nullptr); return var->pieceToCharSynonyms; } inline Rank Position::promotion_rank() const { assert(var != nullptr); return var->promotionRank; } inline const std::set >& Position::promotion_piece_types() const { assert(var != nullptr); return var->promotionPieceTypes; } inline bool Position::sittuyin_promotion() const { assert(var != nullptr); return var->sittuyinPromotion; } inline int Position::promotion_limit(PieceType pt) const { assert(var != nullptr); return var->promotionLimit[pt]; } inline PieceType Position::promoted_piece_type(PieceType pt) const { assert(var != nullptr); return var->promotedPieceType[pt]; } inline bool Position::piece_promotion_on_capture() const { assert(var != nullptr); return var->piecePromotionOnCapture; } inline bool Position::mandatory_pawn_promotion() const { assert(var != nullptr); return var->mandatoryPawnPromotion; } inline bool Position::mandatory_piece_promotion() const { assert(var != nullptr); return var->mandatoryPiecePromotion; } inline bool Position::piece_demotion() const { assert(var != nullptr); return var->pieceDemotion; } inline bool Position::endgame_eval() const { assert(var != nullptr); return var->endgameEval && !count_in_hand(WHITE, ALL_PIECES) && !count_in_hand(BLACK, ALL_PIECES); } inline bool Position::double_step_enabled() const { assert(var != nullptr); return var->doubleStep; } inline Rank Position::double_step_rank() const { assert(var != nullptr); return var->doubleStepRank; } inline bool Position::first_rank_double_steps() const { assert(var != nullptr); return var->firstRankDoubleSteps; } inline bool Position::castling_enabled() const { assert(var != nullptr); return var->castling; } inline bool Position::castling_dropped_piece() const { assert(var != nullptr); return var->castlingDroppedPiece; } inline File Position::castling_kingside_file() const { assert(var != nullptr); return var->castlingKingsideFile; } inline File Position::castling_queenside_file() const { assert(var != nullptr); return var->castlingQueensideFile; } inline Rank Position::castling_rank(Color c) const { assert(var != nullptr); return relative_rank(c, var->castlingRank, max_rank()); } inline PieceType Position::castling_rook_piece() const { assert(var != nullptr); return var->castlingRookPiece; } inline PieceType Position::king_type() const { assert(var != nullptr); return var->kingType; } inline bool Position::checking_permitted() const { assert(var != nullptr); return var->checking; } inline bool Position::drop_checks() const { assert(var != nullptr); return var->dropChecks; } inline bool Position::must_capture() const { assert(var != nullptr); return var->mustCapture; } inline bool Position::must_drop() const { assert(var != nullptr); return var->mustDrop; } inline bool Position::piece_drops() const { assert(var != nullptr); return var->pieceDrops; } inline bool Position::drop_loop() const { assert(var != nullptr); return var->dropLoop; } inline bool Position::captures_to_hand() const { assert(var != nullptr); return var->capturesToHand; } inline bool Position::first_rank_pawn_drops() const { assert(var != nullptr); return var->firstRankPawnDrops; } inline bool Position::drop_on_top() const { assert(var != nullptr); return var->dropOnTop; } inline Bitboard Position::drop_region(Color c) const { assert(var != nullptr); return c == WHITE ? var->whiteDropRegion : var->blackDropRegion; } inline Bitboard Position::drop_region(Color c, PieceType pt) const { Bitboard b = drop_region(c) & board_bb(c, pt); // Connect4-style drops if (drop_on_top()) b &= shift(pieces()) | Rank1BB; // Pawns on back ranks if (pt == PAWN) { if (!var->promotionZonePawnDrops) b &= ~promotion_zone_bb(c, promotion_rank(), max_rank()); if (!first_rank_pawn_drops()) b &= ~rank_bb(relative_rank(c, RANK_1, max_rank())); } // Doubled shogi pawns if (pt == SHOGI_PAWN && !shogi_doubled_pawn()) for (File f = FILE_A; f <= max_file(); ++f) if (file_bb(f) & pieces(c, pt)) b &= ~file_bb(f); // Sittuyin rook drops if (pt == ROOK && sittuyin_rook_drop()) b &= rank_bb(relative_rank(c, RANK_1, max_rank())); return b; } inline bool Position::sittuyin_rook_drop() const { assert(var != nullptr); return var->sittuyinRookDrop; } inline bool Position::drop_opposite_colored_bishop() const { assert(var != nullptr); return var->dropOppositeColoredBishop; } inline bool Position::drop_promoted() const { assert(var != nullptr); return var->dropPromoted; } inline bool Position::shogi_doubled_pawn() const { assert(var != nullptr); return var->shogiDoubledPawn; } inline bool Position::immobility_illegal() const { assert(var != nullptr); return var->immobilityIllegal; } inline bool Position::gating() const { assert(var != nullptr); return var->gating; } inline bool Position::seirawan_gating() const { assert(var != nullptr); return var->seirawanGating; } inline bool Position::cambodian_moves() const { assert(var != nullptr); return var->cambodianMoves; } inline Bitboard Position::diagonal_lines() const { assert(var != nullptr); return var->diagonalLines; } inline bool Position::king_pass() const { assert(var != nullptr); return var->kingPass || var->kingPassOnStalemate; } inline bool Position::king_pass_on_stalemate() const { assert(var != nullptr); return var->kingPassOnStalemate; } inline Bitboard Position::promoted_soldiers(Color c) const { assert(var != nullptr); return pieces(c, SOLDIER) & promotion_zone_bb(c, var->soldierPromotionRank, max_rank()); } inline bool Position::makpong() const { assert(var != nullptr); return var->makpongRule; } inline int Position::n_move_rule() const { assert(var != nullptr); return var->nMoveRule; } inline int Position::n_fold_rule() const { assert(var != nullptr); return var->nFoldRule; } inline Value Position::stalemate_value(int ply) const { assert(var != nullptr); if (var->stalematePieceCount) { int c = count(sideToMove) - count(~sideToMove); return c == 0 ? VALUE_DRAW : convert_mate_value(c < 0 ? var->stalemateValue : -var->stalemateValue, ply); } return convert_mate_value(var->stalemateValue, ply); } inline Value Position::checkmate_value(int ply) const { assert(var != nullptr); // Check for illegal mate by shogi pawn drop if ( var->shogiPawnDropMateIllegal && !(checkers() & ~pieces(SHOGI_PAWN)) && !st->capturedPiece && st->pliesFromNull > 0 && (st->materialKey != st->previous->materialKey)) { return mate_in(ply); } // Check for shatar mate rule if (var->shatarMateRule) { // Mate by knight is illegal if (!(checkers() & ~pieces(KNIGHT))) return mate_in(ply); StateInfo* stp = st; while (stp->checkersBB) { // Return mate score if there is at least one shak in series of checks if (stp->shak) return convert_mate_value(var->checkmateValue, ply); if (stp->pliesFromNull < 2) break; stp = stp->previous->previous; } // Niol return VALUE_DRAW; } // Return mate value return convert_mate_value(var->checkmateValue, ply); } inline Value Position::extinction_value(int ply) const { assert(var != nullptr); return convert_mate_value(var->extinctionValue, ply); } inline bool Position::extinction_claim() const { assert(var != nullptr); return var->extinctionClaim; } inline const std::set& Position::extinction_piece_types() const { assert(var != nullptr); return var->extinctionPieceTypes; } inline int Position::extinction_piece_count() const { assert(var != nullptr); return var->extinctionPieceCount; } inline int Position::extinction_opponent_piece_count() const { assert(var != nullptr); return var->extinctionOpponentPieceCount; } inline PieceType Position::capture_the_flag_piece() const { assert(var != nullptr); return var->flagPiece; } inline Bitboard Position::capture_the_flag(Color c) const { assert(var != nullptr); return c == WHITE ? var->whiteFlag : var->blackFlag; } inline bool Position::flag_move() const { assert(var != nullptr); return var->flagMove; } inline bool Position::check_counting() const { assert(var != nullptr); return var->checkCounting; } inline int Position::connect_n() const { assert(var != nullptr); return var->connectN; } inline CheckCount Position::checks_remaining(Color c) const { return st->checksRemaining[c]; } inline MaterialCounting Position::material_counting() const { assert(var != nullptr); return var->materialCounting; } inline CountingRule Position::counting_rule() const { assert(var != nullptr); return var->countingRule; } inline bool Position::is_immediate_game_end() const { Value result; return is_immediate_game_end(result); } inline bool Position::is_game_end(Value& result, int ply) const { return is_immediate_game_end(result, ply) || is_optional_game_end(result, ply); } inline Color Position::side_to_move() const { return sideToMove; } inline bool Position::empty(Square s) const { return board[s] == NO_PIECE; } inline Piece Position::piece_on(Square s) const { return board[s]; } inline Piece Position::unpromoted_piece_on(Square s) const { return unpromotedBoard[s]; } inline Piece Position::moved_piece(Move m) const { if (type_of(m) == DROP) return make_piece(sideToMove, dropped_piece_type(m)); return board[from_sq(m)]; } inline Bitboard Position::pieces() const { return byTypeBB[ALL_PIECES]; } inline Bitboard Position::pieces(PieceType pt) const { return byTypeBB[pt]; } inline Bitboard Position::pieces(PieceType pt1, PieceType pt2) const { return byTypeBB[pt1] | byTypeBB[pt2]; } inline Bitboard Position::pieces(Color c) const { return byColorBB[c]; } inline Bitboard Position::pieces(Color c, PieceType pt) const { return byColorBB[c] & byTypeBB[pt]; } inline Bitboard Position::pieces(Color c, PieceType pt1, PieceType pt2) const { return byColorBB[c] & (byTypeBB[pt1] | byTypeBB[pt2]); } inline Bitboard Position::major_pieces(Color c) const { return byColorBB[c] & (byTypeBB[QUEEN] | byTypeBB[AIWOK] | byTypeBB[ARCHBISHOP] | byTypeBB[CHANCELLOR] | byTypeBB[AMAZON]); } inline int Position::count(Color c, PieceType pt) const { return pieceCount[make_piece(c, pt)]; } template inline int Position::count(Color c) const { return pieceCount[make_piece(c, Pt)]; } template inline int Position::count() const { return pieceCount[make_piece(WHITE, Pt)] + pieceCount[make_piece(BLACK, Pt)]; } template inline const Square* Position::squares(Color c) const { return pieceList[make_piece(c, Pt)]; } inline const Square* Position::squares(Color c, PieceType pt) const { return pieceList[make_piece(c, pt)]; } template inline Square Position::square(Color c) const { assert(pieceCount[make_piece(c, Pt)] == 1); return pieceList[make_piece(c, Pt)][0]; } inline Square Position::ep_square() const { return st->epSquare; } inline Bitboard Position::gates(Color c) const { assert(var != nullptr); return st->gatesBB[c]; } inline bool Position::is_on_semiopen_file(Color c, Square s) const { return !(pieces(c, PAWN, SHOGI_PAWN) & file_bb(s)); } inline bool Position::can_castle(CastlingRights cr) const { return st->castlingRights & cr; } inline int Position::castling_rights(Color c) const { return st->castlingRights & (c == WHITE ? WHITE_CASTLING : BLACK_CASTLING); } inline bool Position::castling_impeded(CastlingRights cr) const { assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO); return byTypeBB[ALL_PIECES] & castlingPath[cr]; } inline Square Position::castling_rook_square(CastlingRights cr) const { assert(cr == WHITE_OO || cr == WHITE_OOO || cr == BLACK_OO || cr == BLACK_OOO); return castlingRookSquare[cr]; } template inline Bitboard Position::attacks_from(Square s, Color c) const { return attacks_from(c, Pt, s); } inline Bitboard Position::attacks_from(Color c, PieceType pt, Square s) const { PieceType movePt = pt == KING ? king_type() : pt; Bitboard b = attacks_bb(c, movePt, s, byTypeBB[ALL_PIECES]); // Xiangqi soldier if (pt == SOLDIER && !(promoted_soldiers(c) & s)) b &= file_bb(file_of(s)); // Janggi cannon restrictions if (pt == JANGGI_CANNON) { b &= ~pieces(pt); b &= attacks_bb(c, pt, s, pieces() ^ pieces(pt)); } // Janggi palace moves if (diagonal_lines() & s) { PieceType diagType = movePt == WAZIR ? FERS : movePt == SOLDIER ? PAWN : movePt == ROOK ? BISHOP : NO_PIECE_TYPE; if (diagType) b |= attacks_bb(c, diagType, s, pieces()) & diagonal_lines(); else if (movePt == JANGGI_CANNON) // TODO: fix for longer diagonals b |= attacks_bb(c, ALFIL, s, pieces()) & ~attacks_bb(c, ELEPHANT, s, pieces() ^ pieces(pt)) & ~pieces(pt) & diagonal_lines(); } return b & board_bb(c, pt); } inline Bitboard Position::moves_from(Color c, PieceType pt, Square s) const { PieceType movePt = pt == KING ? king_type() : pt; Bitboard b = moves_bb(c, movePt, s, byTypeBB[ALL_PIECES]); // Xiangqi soldier if (pt == SOLDIER && !(promoted_soldiers(c) & s)) b &= file_bb(file_of(s)); // Janggi cannon restrictions if (pt == JANGGI_CANNON) { b &= ~pieces(pt); b &= attacks_bb(c, pt, s, pieces() ^ pieces(pt)); } // Janggi palace moves if (diagonal_lines() & s) { PieceType diagType = movePt == WAZIR ? FERS : movePt == SOLDIER ? PAWN : movePt == ROOK ? BISHOP : NO_PIECE_TYPE; if (diagType) b |= attacks_bb(c, diagType, s, pieces()) & diagonal_lines(); else if (movePt == JANGGI_CANNON) // TODO: fix for longer diagonals b |= attacks_bb(c, ALFIL, s, pieces()) & ~attacks_bb(c, ELEPHANT, s, pieces() ^ pieces(pt)) & ~pieces(pt) & diagonal_lines(); } return b & board_bb(c, pt); } inline Bitboard Position::attackers_to(Square s) const { return attackers_to(s, byTypeBB[ALL_PIECES]); } inline Bitboard Position::attackers_to(Square s, Color c) const { return attackers_to(s, byTypeBB[ALL_PIECES], c); } inline Bitboard Position::attackers_to(Square s, Bitboard occupied, Color c) const { return attackers_to(s, occupied, c, byTypeBB[JANGGI_CANNON]); } inline Bitboard Position::checkers() const { return st->checkersBB; } inline Bitboard Position::blockers_for_king(Color c) const { return st->blockersForKing[c]; } inline Bitboard Position::check_squares(PieceType pt) const { return st->checkSquares[pt]; } inline bool Position::is_discovery_check_on_king(Color c, Move m) const { return is_ok(from_sq(m)) && st->blockersForKing[c] & from_sq(m); } inline bool Position::pawn_passed(Color c, Square s) const { return !(pieces(~c, PAWN) & passed_pawn_span(c, s)); } inline bool Position::advanced_pawn_push(Move m) const { return type_of(moved_piece(m)) == PAWN && relative_rank(sideToMove, to_sq(m), max_rank()) > (max_rank() + 1) / 2; } inline int Position::pawns_on_same_color_squares(Color c, Square s) const { return popcount(pieces(c, PAWN) & ((DarkSquares & s) ? DarkSquares : ~DarkSquares)); } inline Key Position::key() const { return st->key; } inline Key Position::pawn_key() const { return st->pawnKey; } inline Key Position::material_key() const { return st->materialKey; } inline Score Position::psq_score() const { return psq; } inline Value Position::non_pawn_material(Color c) const { return st->nonPawnMaterial[c]; } inline Value Position::non_pawn_material() const { return st->nonPawnMaterial[WHITE] + st->nonPawnMaterial[BLACK]; } inline int Position::game_ply() const { return gamePly; } inline int Position::counting_ply(int countStarted) const { return countStarted == 0 ? st->countingPly : std::min(st->countingPly, std::max(1 + gamePly - countStarted, 0)); } inline int Position::rule50_count() const { return st->rule50; } inline bool Position::opposite_bishops() const { return pieceCount[make_piece(WHITE, BISHOP)] == 1 && pieceCount[make_piece(BLACK, BISHOP)] == 1 && opposite_colors(square(WHITE), square(BLACK)); } inline bool Position::is_promoted(Square s) const { return promotedPieces & s; } inline bool Position::is_chess960() const { return chess960; } inline bool Position::capture_or_promotion(Move m) const { assert(is_ok(m)); return type_of(m) == PROMOTION || type_of(m) == ENPASSANT || (type_of(m) != CASTLING && !empty(to_sq(m))); } inline bool Position::capture(Move m) const { assert(is_ok(m)); // Castling is encoded as "king captures rook" return (!empty(to_sq(m)) && type_of(m) != CASTLING && from_sq(m) != to_sq(m)) || type_of(m) == ENPASSANT; } inline Piece Position::captured_piece() const { return st->capturedPiece; } inline Thread* Position::this_thread() const { return thisThread; } inline void Position::put_piece(Piece pc, Square s, bool isPromoted, Piece unpromotedPc) { board[s] = pc; byTypeBB[ALL_PIECES] |= s; byTypeBB[type_of(pc)] |= s; byColorBB[color_of(pc)] |= s; index[s] = pieceCount[pc]++; pieceList[pc][index[s]] = s; pieceCount[make_piece(color_of(pc), ALL_PIECES)]++; psq += PSQT::psq[pc][s]; if (isPromoted) promotedPieces |= s; unpromotedBoard[s] = unpromotedPc; } inline void Position::remove_piece(Piece pc, Square s) { // WARNING: This is not a reversible operation. If we remove a piece in // do_move() and then replace it in undo_move() we will put it at the end of // the list and not in its original place, it means index[] and pieceList[] // are not invariant to a do_move() + undo_move() sequence. byTypeBB[ALL_PIECES] ^= s; byTypeBB[type_of(pc)] ^= s; byColorBB[color_of(pc)] ^= s; /* board[s] = NO_PIECE; Not needed, overwritten by the capturing one */ Square lastSquare = pieceList[pc][--pieceCount[pc]]; index[lastSquare] = index[s]; pieceList[pc][index[lastSquare]] = lastSquare; pieceList[pc][pieceCount[pc]] = SQ_NONE; pieceCount[make_piece(color_of(pc), ALL_PIECES)]--; psq -= PSQT::psq[pc][s]; promotedPieces -= s; unpromotedBoard[s] = NO_PIECE; } inline void Position::move_piece(Piece pc, Square from, Square to) { // index[from] is not updated and becomes stale. This works as long as index[] // is accessed just by known occupied squares. Bitboard fromTo = square_bb(from) ^ to; // from == to needs to cancel out byTypeBB[ALL_PIECES] ^= fromTo; byTypeBB[type_of(pc)] ^= fromTo; byColorBB[color_of(pc)] ^= fromTo; board[from] = NO_PIECE; board[to] = pc; index[to] = index[from]; pieceList[pc][index[to]] = to; psq += PSQT::psq[pc][to] - PSQT::psq[pc][from]; if (is_promoted(from)) promotedPieces ^= fromTo; unpromotedBoard[to] = unpromotedBoard[from]; unpromotedBoard[from] = NO_PIECE; } inline void Position::do_move(Move m, StateInfo& newSt) { do_move(m, newSt, gives_check(m)); } inline int Position::count_in_hand(Color c, PieceType pt) const { return pieceCountInHand[c][pt]; } inline int Position::count_with_hand(Color c, PieceType pt) const { return pieceCount[make_piece(c, pt)] + pieceCountInHand[c][pt]; } inline bool Position::bikjang() const { return st->bikjang; } inline Value Position::material_counting_result() const { auto weigth_count = [this](PieceType pt, int v){ return v * (count(WHITE, pt) - count(BLACK, pt)); }; int materialCount; Value result; switch (var->materialCounting) { case JANGGI_MATERIAL: materialCount = weigth_count(ROOK, 13) + weigth_count(JANGGI_CANNON, 7) + weigth_count(HORSE, 5) + weigth_count(JANGGI_ELEPHANT, 3) + weigth_count(WAZIR, 3) + weigth_count(SOLDIER, 2) - 1; result = materialCount > 0 ? VALUE_MATE : -VALUE_MATE; break; case UNWEIGHTED_MATERIAL: result = count(WHITE, ALL_PIECES) > count(BLACK, ALL_PIECES) ? VALUE_MATE : count(WHITE, ALL_PIECES) < count(BLACK, ALL_PIECES) ? -VALUE_MATE : VALUE_DRAW; break; default: assert(false); result = VALUE_DRAW; } return sideToMove == WHITE ? result : -result; } inline void Position::add_to_hand(Piece pc) { pieceCountInHand[color_of(pc)][type_of(pc)]++; pieceCountInHand[color_of(pc)][ALL_PIECES]++; psq += PSQT::psq[pc][SQ_NONE]; } inline void Position::remove_from_hand(Piece pc) { pieceCountInHand[color_of(pc)][type_of(pc)]--; pieceCountInHand[color_of(pc)][ALL_PIECES]--; psq -= PSQT::psq[pc][SQ_NONE]; } inline void Position::drop_piece(Piece pc_hand, Piece pc_drop, Square s) { assert(pieceCountInHand[color_of(pc_hand)][type_of(pc_hand)]); put_piece(pc_drop, s, pc_drop != pc_hand, pc_drop != pc_hand ? pc_hand : NO_PIECE); remove_from_hand(pc_hand); } inline void Position::undrop_piece(Piece pc_hand, Piece pc_drop, Square s) { remove_piece(pc_drop, s); board[s] = NO_PIECE; add_to_hand(pc_hand); assert(pieceCountInHand[color_of(pc_hand)][type_of(pc_hand)]); } #endif // #ifndef POSITION_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/psqt.cpp000066400000000000000000000236731366242550200207060ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include "types.h" #include "piece.h" #include "variant.h" Value PieceValue[PHASE_NB][PIECE_NB] = { { VALUE_ZERO, PawnValueMg, KnightValueMg, BishopValueMg, RookValueMg, QueenValueMg, FersValueMg, AlfilValueMg, FersAlfilValueMg, SilverValueMg, AiwokValueMg, BersValueMg, ArchbishopValueMg, ChancellorValueMg, AmazonValueMg, KnibisValueMg, BiskniValueMg, KnirooValueMg, RookniValueMg, ShogiPawnValueMg, LanceValueMg, ShogiKnightValueMg, EuroShogiKnightValueMg, GoldValueMg, DragonHorseValueMg, ClobberPieceValueMg, BreakthroughPieceValueMg, ImmobilePieceValueMg, CannonPieceValueMg, JanggiCannonPieceValueMg, SoldierValueMg, HorseValueMg, ElephantValueMg, JanggiElephantValueMg, BannerValueMg, WazirValueMg, CommonerValueMg, CentaurValueMg }, { VALUE_ZERO, PawnValueEg, KnightValueEg, BishopValueEg, RookValueEg, QueenValueEg, FersValueEg, AlfilValueEg, FersAlfilValueEg, SilverValueEg, AiwokValueEg, BersValueEg, ArchbishopValueMg, ChancellorValueEg, AmazonValueEg, KnibisValueMg, BiskniValueMg, KnirooValueEg, RookniValueEg, ShogiPawnValueEg, LanceValueEg, ShogiKnightValueEg, EuroShogiKnightValueEg, GoldValueEg, DragonHorseValueEg, ClobberPieceValueEg, BreakthroughPieceValueEg, ImmobilePieceValueEg, CannonPieceValueEg, JanggiCannonPieceValueEg, SoldierValueEg, HorseValueEg, ElephantValueEg, JanggiElephantValueEg, BannerValueEg, WazirValueEg, CommonerValueEg, CentaurValueEg } }; namespace PSQT { #define S(mg, eg) make_score(mg, eg) // Bonus[PieceType][Square / 2] contains Piece-Square scores. For each piece // type on a given square a (middlegame, endgame) score pair is assigned. Table // is defined for files A..D and white side: it is symmetric for black side and // second half of the files. constexpr Score Bonus[PIECE_TYPE_NB][RANK_NB][int(FILE_NB) / 2] = { { }, { }, { // Knight { S(-175, -96), S(-92,-65), S(-74,-49), S(-73,-21) }, { S( -77, -67), S(-41,-54), S(-27,-18), S(-15, 8) }, { S( -61, -40), S(-17,-27), S( 6, -8), S( 12, 29) }, { S( -35, -35), S( 8, -2), S( 40, 13), S( 49, 28) }, { S( -34, -45), S( 13,-16), S( 44, 9), S( 51, 39) }, { S( -9, -51), S( 22,-44), S( 58,-16), S( 53, 17) }, { S( -67, -69), S(-27,-50), S( 4,-51), S( 37, 12) }, { S(-201,-100), S(-83,-88), S(-56,-56), S(-26,-17) } }, { // Bishop { S(-53,-57), S( -5,-30), S( -8,-37), S(-23,-12) }, { S(-15,-37), S( 8,-13), S( 19,-17), S( 4, 1) }, { S( -7,-16), S( 21, -1), S( -5, -2), S( 17, 10) }, { S( -5,-20), S( 11, -6), S( 25, 0), S( 39, 17) }, { S(-12,-17), S( 29, -1), S( 22,-14), S( 31, 15) }, { S(-16,-30), S( 6, 6), S( 1, 4), S( 11, 6) }, { S(-17,-31), S(-14,-20), S( 5, -1), S( 0, 1) }, { S(-48,-46), S( 1,-42), S(-14,-37), S(-23,-24) } }, { // Rook { S(-31, -9), S(-20,-13), S(-14,-10), S(-5, -9) }, { S(-21,-12), S(-13, -9), S( -8, -1), S( 6, -2) }, { S(-25, 6), S(-11, -8), S( -1, -2), S( 3, -6) }, { S(-13, -6), S( -5, 1), S( -4, -9), S(-6, 7) }, { S(-27, -5), S(-15, 8), S( -4, 7), S( 3, -6) }, { S(-22, 6), S( -2, 1), S( 6, -7), S(12, 10) }, { S( -2, 4), S( 12, 5), S( 16, 20), S(18, -5) }, { S(-17, 18), S(-19, 0), S( -1, 19), S( 9, 13) } }, { // Queen { S( 3,-69), S(-5,-57), S(-5,-47), S( 4,-26) }, { S(-3,-55), S( 5,-31), S( 8,-22), S(12, -4) }, { S(-3,-39), S( 6,-18), S(13, -9), S( 7, 3) }, { S( 4,-23), S( 5, -3), S( 9, 13), S( 8, 24) }, { S( 0,-29), S(14, -6), S(12, 9), S( 5, 21) }, { S(-4,-38), S(10,-18), S( 6,-12), S( 8, 1) }, { S(-5,-50), S( 6,-27), S(10,-24), S( 8, -8) }, { S(-2,-75), S(-2,-52), S( 1,-43), S(-2,-36) } } }; constexpr Score KingBonus[RANK_NB][int(FILE_NB) / 2] = { { S(271, 1), S(327, 45), S(271, 85), S(198, 76) }, { S(278, 53), S(303,100), S(234,133), S(179,135) }, { S(195, 88), S(258,130), S(169,169), S(120,175) }, { S(164,103), S(190,156), S(138,172), S( 98,172) }, { S(154, 96), S(179,166), S(105,199), S( 70,199) }, { S(123, 92), S(145,172), S( 81,184), S( 31,191) }, { S( 88, 47), S(120,121), S( 65,116), S( 33,131) }, { S( 59, 11), S( 89, 59), S( 45, 73), S( -1, 78) } }; constexpr Score PBonus[RANK_NB][FILE_NB] = { // Pawn (asymmetric distribution) { }, { S( 3,-10), S( 3, -6), S( 10, 10), S( 19, 0), S( 16, 14), S( 19, 7), S( 7, -5), S( -5,-19) }, { S( -9,-10), S(-15,-10), S( 11,-10), S( 15, 4), S( 32, 4), S( 22, 3), S( 5, -6), S(-22, -4) }, { S( -8, 6), S(-23, -2), S( 6, -8), S( 20, -4), S( 40,-13), S( 17,-12), S( 4,-10), S(-12, -9) }, { S( 13, 9), S( 0, 4), S(-13, 3), S( 1,-12), S( 11,-12), S( -2, -6), S(-13, 13), S( 5, 8) }, { S( -5, 28), S(-12, 20), S( -7, 21), S( 22, 28), S( -8, 30), S( -5, 7), S(-15, 6), S(-18, 13) }, { S( -7, 0), S( 7,-11), S( -3, 12), S(-13, 21), S( 5, 25), S(-16, 19), S( 10, 4), S( -8, 7) } }; #undef S Score psq[PIECE_NB][SQUARE_NB + 1]; // init() initializes piece-square tables: the white halves of the tables are // copied from Bonus[] adding the piece value, then the black halves of the // tables are initialized by flipping and changing the sign of the white scores. void init(const Variant* v) { PieceType strongestPiece = NO_PIECE_TYPE; for (PieceType pt : v->pieceTypes) if (PieceValue[MG][pt] > PieceValue[MG][strongestPiece]) strongestPiece = pt; for (PieceType pt = PAWN; pt <= KING; ++pt) { Piece pc = make_piece(WHITE, pt); PieceValue[MG][~pc] = PieceValue[MG][pc]; PieceValue[EG][~pc] = PieceValue[EG][pc]; Score score = make_score(PieceValue[MG][pc], PieceValue[EG][pc]); // Scale slider piece values with board size const PieceInfo* pi = pieceMap.find(pt)->second; if (pi->sliderQuiet.size() || pi->sliderCapture.size()) { constexpr int lc = 5; constexpr int rm = 5; constexpr int r0 = rm + RANK_8; int r1 = rm + (v->maxRank + v->maxFile) / 2; int leaper = pi->stepsQuiet.size() + pi->stepsCapture.size(); int slider = pi->sliderQuiet.size() + pi->sliderCapture.size(); score = make_score(mg_value(score) * (lc * leaper + r1 * slider) / (lc * leaper + r0 * slider), eg_value(score) * (lc * leaper + r1 * slider) / (lc * leaper + r0 * slider)); } // Increase leapers' value in makpong if (v->makpongRule) { if (std::any_of(pi->stepsCapture.begin(), pi->stepsCapture.end(), [](Direction d) { return dist(d) > 1; }) && !pi->lameLeaper) score = make_score(mg_value(score) * 4200 / (3500 + mg_value(score)), eg_value(score) * 4700 / (3500 + mg_value(score))); } // For drop variants, halve the piece values if (v->capturesToHand) score = make_score(mg_value(score) * 3500 / (7000 + mg_value(score)), eg_value(score) * 3500 / (7000 + eg_value(score))); else if (!v->checking) score = make_score(mg_value(score) * 2000 / (3500 + mg_value(score)), eg_value(score) * 2200 / (3500 + eg_value(score))); else if (v->twoBoards) score = make_score(mg_value(score) * 7000 / (7000 + mg_value(score)), eg_value(score) * 7000 / (7000 + eg_value(score))); else if (v->checkCounting) score = make_score(mg_value(score) * (40000 + mg_value(score)) / 41000, eg_value(score) * (30000 + eg_value(score)) / 31000); else if (pt == strongestPiece) score += make_score(std::max(QueenValueMg - PieceValue[MG][pt], VALUE_ZERO) / 20, std::max(QueenValueEg - PieceValue[EG][pt], VALUE_ZERO) / 20); // For antichess variants, use negative piece values if ( v->extinctionValue == VALUE_MATE && v->extinctionPieceTypes.find(ALL_PIECES) != v->extinctionPieceTypes.end()) score = -make_score(mg_value(score) / 8, eg_value(score) / 8 / (1 + !pi->sliderCapture.size())); for (Square s = SQ_A1; s <= SQ_MAX; ++s) { File f = std::max(std::min(file_of(s), File(v->maxFile - file_of(s))), FILE_A); Rank r = rank_of(s); psq[ pc][ s] = score + ( pt == PAWN ? PBonus[std::min(r, RANK_8)][std::min(file_of(s), FILE_H)] : pt == KING ? KingBonus[std::min(r, RANK_8)][std::min(f, FILE_D)] * (1 + v->capturesToHand) : pt <= QUEEN ? Bonus[pc][std::min(r, RANK_8)][std::min(f, FILE_D)] : pt == HORSE ? Bonus[KNIGHT][std::min(r, RANK_8)][std::min(f, FILE_D)] : make_score(5, 5) * (2 * f + std::max(std::min(r, Rank(v->maxRank - r)), RANK_1) - 8)); if (pt == SOLDIER && r < v->soldierPromotionRank) psq[pc][s] -= score * (v->soldierPromotionRank - r) / (4 + f); psq[~pc][rank_of(s) <= v->maxRank ? relative_square(BLACK, s, v->maxRank) : s] = -psq[pc][s]; } // pieces in pocket psq[ pc][SQ_NONE] = score + make_score(45, 10); psq[~pc][SQ_NONE] = -psq[pc][SQ_NONE]; } } } // namespace PSQT Fairy-Stockfish-fairy_sf_11_1/src/pyffish.cpp000066400000000000000000000567231366242550200213710ustar00rootroot00000000000000/* Based on Jean-Francois Romang work https://github.com/jromang/Stockfish/blob/pyfish/src/pyfish.cpp */ #include #include "misc.h" #include "types.h" #include "bitboard.h" #include "evaluate.h" #include "position.h" #include "search.h" #include "syzygy/tbprobe.h" #include "thread.h" #include "tt.h" #include "uci.h" #include "piece.h" #include "variant.h" static PyObject* PyFFishError; namespace PSQT { void init(const Variant* v); } namespace { enum Notation { NOTATION_DEFAULT, // https://en.wikipedia.org/wiki/Algebraic_notation_(chess) NOTATION_SAN, NOTATION_LAN, // https://en.wikipedia.org/wiki/Shogi_notation#Western_notation NOTATION_SHOGI_HOSKING, // Examples: P76, S’34 NOTATION_SHOGI_HODGES, // Examples: P-7f, S*3d NOTATION_SHOGI_HODGES_NUMBER, // Examples: P-76, S*34 // http://www.janggi.pl/janggi-notation/ NOTATION_JANGGI, // https://en.wikipedia.org/wiki/Xiangqi#Notation NOTATION_XIANGQI_WXF, }; Notation default_notation(const Variant* v) { if (v->variantTemplate == "shogi") return NOTATION_SHOGI_HODGES_NUMBER; return NOTATION_SAN; } enum Disambiguation { NO_DISAMBIGUATION, FILE_DISAMBIGUATION, RANK_DISAMBIGUATION, SQUARE_DISAMBIGUATION, }; bool is_shogi(Notation n) { return n == NOTATION_SHOGI_HOSKING || n == NOTATION_SHOGI_HODGES || n == NOTATION_SHOGI_HODGES_NUMBER; } std::string piece(const Position& pos, Move m, Notation n) { Color us = pos.side_to_move(); Square from = from_sq(m); Piece pc = pos.moved_piece(m); PieceType pt = type_of(pc); // Quiet pawn moves if ((n == NOTATION_SAN || n == NOTATION_LAN) && type_of(pc) == PAWN && type_of(m) != DROP) return ""; // Tandem pawns else if (n == NOTATION_XIANGQI_WXF && popcount(pos.pieces(us, pt) & file_bb(from)) > 2) return std::to_string(popcount(forward_file_bb(us, from) & pos.pieces(us, pt)) + 1); // Moves of promoted pieces else if (is_shogi(n) && type_of(m) != DROP && pos.unpromoted_piece_on(from)) return "+" + std::string(1, toupper(pos.piece_to_char()[pos.unpromoted_piece_on(from)])); // Promoted drops else if (is_shogi(n) && type_of(m) == DROP && dropped_piece_type(m) != in_hand_piece_type(m)) return "+" + std::string(1, toupper(pos.piece_to_char()[in_hand_piece_type(m)])); else if (pos.piece_to_char_synonyms()[pc] != ' ') return std::string(1, toupper(pos.piece_to_char_synonyms()[pc])); else return std::string(1, toupper(pos.piece_to_char()[pc])); } std::string file(const Position& pos, Square s, Notation n) { switch (n) { case NOTATION_SHOGI_HOSKING: case NOTATION_SHOGI_HODGES: case NOTATION_SHOGI_HODGES_NUMBER: return std::to_string(pos.max_file() - file_of(s) + 1); case NOTATION_JANGGI: return std::to_string(file_of(s) + 1); case NOTATION_XIANGQI_WXF: return std::to_string((pos.side_to_move() == WHITE ? pos.max_file() - file_of(s) : file_of(s)) + 1); default: return std::string(1, char('a' + file_of(s))); } } std::string rank(const Position& pos, Square s, Notation n) { switch (n) { case NOTATION_SHOGI_HOSKING: case NOTATION_SHOGI_HODGES_NUMBER: return std::to_string(pos.max_rank() - rank_of(s) + 1); case NOTATION_SHOGI_HODGES: return std::string(1, char('a' + pos.max_rank() - rank_of(s))); case NOTATION_JANGGI: return std::to_string((pos.max_rank() - rank_of(s) + 1) % 10); case NOTATION_XIANGQI_WXF: { if (pos.empty(s)) return std::to_string(relative_rank(pos.side_to_move(), s, pos.max_rank()) + 1); else if (pos.pieces(pos.side_to_move(), type_of(pos.piece_on(s))) & forward_file_bb(pos.side_to_move(), s)) return "-"; else return "+"; } default: return std::to_string(rank_of(s) + 1); } } std::string square(const Position& pos, Square s, Notation n) { switch (n) { case NOTATION_JANGGI: return rank(pos, s, n) + file(pos, s, n); default: return file(pos, s, n) + rank(pos, s, n); } } Disambiguation disambiguation_level(const Position& pos, Move m, Notation n) { // Drops never need disambiguation if (type_of(m) == DROP) return NO_DISAMBIGUATION; // NOTATION_LAN and Janggi always use disambiguation if (n == NOTATION_LAN || n == NOTATION_JANGGI) return SQUARE_DISAMBIGUATION; Color us = pos.side_to_move(); Square from = from_sq(m); Square to = to_sq(m); Piece pc = pos.moved_piece(m); PieceType pt = type_of(pc); // Xiangqi uses either file disambiguation or +/- if two pieces on file if (n == NOTATION_XIANGQI_WXF) { // Disambiguate by rank (+/-) if target square of other piece is valid if (popcount(pos.pieces(us, pt) & file_bb(from)) == 2) { Square otherFrom = lsb((pos.pieces(us, pt) & file_bb(from)) ^ from); Square otherTo = otherFrom + Direction(to) - Direction(from); if (is_ok(otherTo) && (pos.board_bb(us, pt) & otherTo)) return RANK_DISAMBIGUATION; } return FILE_DISAMBIGUATION; } // Pawn captures always use disambiguation if (n == NOTATION_SAN && pt == PAWN) { if (pos.capture(m)) return FILE_DISAMBIGUATION; if (type_of(m) == PROMOTION && from != to && pos.sittuyin_promotion()) return SQUARE_DISAMBIGUATION; } // A disambiguation occurs if we have more then one piece of type 'pt' // that can reach 'to' with a legal move. Bitboard others, b; others = b = ((pos.capture(m) ? attacks_bb(~us, pt, to, AttackRiderTypes[pt] & ASYMMETRICAL_RIDERS ? Bitboard(0) : pos.pieces()) : moves_bb( ~us, pt, to, MoveRiderTypes[pt] & ASYMMETRICAL_RIDERS ? Bitboard(0) : pos.pieces())) & pos.pieces(us, pt)) & ~square_bb(from); while (b) { Square s = pop_lsb(&b); if ( !pos.pseudo_legal(make_move(s, to)) || !pos.legal(make_move(s, to)) || (is_shogi(n) && pos.unpromoted_piece_on(s) != pos.unpromoted_piece_on(from))) others ^= s; } if (!others) return NO_DISAMBIGUATION; else if (is_shogi(n)) return SQUARE_DISAMBIGUATION; else if (!(others & file_bb(from))) return FILE_DISAMBIGUATION; else if (!(others & rank_bb(from))) return RANK_DISAMBIGUATION; else return SQUARE_DISAMBIGUATION; } std::string disambiguation(const Position& pos, Square s, Notation n, Disambiguation d) { switch (d) { case FILE_DISAMBIGUATION: return file(pos, s, n); case RANK_DISAMBIGUATION: return rank(pos, s, n); case SQUARE_DISAMBIGUATION: return square(pos, s, n); default: assert(d == NO_DISAMBIGUATION); return ""; } } const std::string move_to_san(Position& pos, Move m, Notation n) { std::string san = ""; Color us = pos.side_to_move(); Square from = from_sq(m); Square to = to_sq(m); if (type_of(m) == CASTLING) { san = to > from ? "O-O" : "O-O-O"; if (is_gating(m)) { san += std::string("/") + pos.piece_to_char()[make_piece(WHITE, gating_type(m))]; san += square(pos, gating_square(m), n); } } else { // Piece san += piece(pos, m, n); // Origin square, disambiguation Disambiguation d = disambiguation_level(pos, m, n); san += disambiguation(pos, from, n, d); // Separator/Operator if (type_of(m) == DROP) san += n == NOTATION_SHOGI_HOSKING ? '\'' : is_shogi(n) ? '*' : '@'; else if (n == NOTATION_XIANGQI_WXF) { if (rank_of(from) == rank_of(to)) san += '='; else if (relative_rank(us, to, pos.max_rank()) > relative_rank(us, from, pos.max_rank())) san += '+'; else san += '-'; } else if (pos.capture(m)) san += 'x'; else if (n == NOTATION_LAN || (is_shogi(n) && (n != NOTATION_SHOGI_HOSKING || d == SQUARE_DISAMBIGUATION)) || n == NOTATION_JANGGI) san += '-'; // Destination square if (n == NOTATION_XIANGQI_WXF && type_of(m) != DROP) san += file_of(to) == file_of(from) ? std::to_string(std::abs(rank_of(to) - rank_of(from))) : file(pos, to, n); else san += square(pos, to, n); // Suffix if (type_of(m) == PROMOTION) san += std::string("=") + pos.piece_to_char()[make_piece(WHITE, promotion_type(m))]; else if (type_of(m) == PIECE_PROMOTION) san += is_shogi(n) ? std::string("+") : std::string("=") + pos.piece_to_char()[make_piece(WHITE, pos.promoted_piece_type(type_of(pos.moved_piece(m))))]; else if (type_of(m) == PIECE_DEMOTION) san += is_shogi(n) ? std::string("-") : std::string("=") + std::string(1, pos.piece_to_char()[pos.unpromoted_piece_on(from)]); else if (type_of(m) == NORMAL && is_shogi(n) && pos.pseudo_legal(make(from, to))) san += std::string("="); if (is_gating(m)) san += std::string("/") + pos.piece_to_char()[make_piece(WHITE, gating_type(m))]; } // Check and checkmate if (pos.gives_check(m) && !is_shogi(n)) { StateInfo st; pos.do_move(m, st); san += MoveList(pos).size() ? "+" : "#"; pos.undo_move(m); } return san; } bool hasInsufficientMaterial(Color c, const Position& pos) { if ( pos.captures_to_hand() || pos.count_in_hand(c, ALL_PIECES) || (pos.capture_the_flag_piece() && pos.count(c, pos.capture_the_flag_piece()))) return false; for (PieceType pt : { ROOK, QUEEN, ARCHBISHOP, CHANCELLOR, SILVER }) if (pos.count(c, pt) || (pos.count(c, PAWN) && pos.promotion_piece_types().find(pt) != pos.promotion_piece_types().end())) return false; // To avoid false positives, treat pawn + anything as sufficient mating material. // This is too conservative for South-East Asian variants. if (pos.count(c, PAWN) && pos.count() >= 4) return false; if (pos.count(c, KNIGHT) >= 2 || (pos.count(c, KNIGHT) && (pos.count(c, BISHOP) || pos.count(c, FERS) || pos.count(c, FERS_ALFIL)))) return false; // Check for opposite colored color-bound pieces if ( (pos.count(c, BISHOP) || pos.count(c, FERS_ALFIL)) && (DarkSquares & pos.pieces(BISHOP, FERS_ALFIL)) && (~DarkSquares & pos.pieces(BISHOP, FERS_ALFIL))) return false; if (pos.count(c, FERS) && (DarkSquares & pos.pieces(FERS)) && (~DarkSquares & pos.pieces(FERS))) return false; if (pos.pieces(c, CANNON, JANGGI_CANNON) && (pos.count(c, ALL_PIECES) > 2 || pos.count(~c, ALL_PIECES) > 1)) return false; if (pos.count(c, JANGGI_ELEPHANT) >= 2) return false; // Pieces sufficient for stalemate (Xiangqi) if (pos.stalemate_value() != VALUE_DRAW) for (PieceType pt : { HORSE, SOLDIER, JANGGI_ELEPHANT }) if (pos.count(c, pt)) return false; return true; } void buildPosition(Position& pos, StateListPtr& states, const char *variant, const char *fen, PyObject *moveList, const bool chess960) { states = StateListPtr(new std::deque(1)); // Drop old and create a new one const Variant* v = variants.find(std::string(variant))->second; if (strcmp(fen, "startpos") == 0) fen = v->startFen.c_str(); Options["UCI_Chess960"] = chess960; pos.set(v, std::string(fen), chess960, &states->back(), Threads.main()); // parse move list int numMoves = PyList_Size(moveList); for (int i = 0; i < numMoves ; i++) { std::string moveStr(PyBytes_AS_STRING(PyUnicode_AsEncodedString( PyList_GetItem(moveList, i), "UTF-8", "strict"))); Move m; if ((m = UCI::to_move(pos, moveStr)) != MOVE_NONE) { // do the move states->emplace_back(); pos.do_move(m, states->back()); } else PyErr_SetString(PyExc_ValueError, (std::string("Invalid move '") + moveStr + "'").c_str()); } return; } } extern "C" PyObject* pyffish_info(PyObject* self) { return Py_BuildValue("s", engine_info().c_str()); } // INPUT option name, option value extern "C" PyObject* pyffish_setOption(PyObject* self, PyObject *args) { const char *name; PyObject *valueObj; if (!PyArg_ParseTuple(args, "sO", &name, &valueObj)) return NULL; if (Options.count(name)) Options[name] = std::string(PyBytes_AS_STRING(PyUnicode_AsEncodedString(PyObject_Str(valueObj), "UTF-8", "strict"))); else { PyErr_SetString(PyExc_ValueError, (std::string("No such option ") + name + "'").c_str()); return NULL; } Py_RETURN_NONE; } // INPUT variant extern "C" PyObject* pyffish_startFen(PyObject* self, PyObject *args) { const char *variant; if (!PyArg_ParseTuple(args, "s", &variant)) { return NULL; } return Py_BuildValue("s", variants.find(std::string(variant))->second->startFen.c_str()); } // INPUT variant extern "C" PyObject* pyffish_twoBoards(PyObject* self, PyObject *args) { const char *variant; if (!PyArg_ParseTuple(args, "s", &variant)) { return NULL; } return Py_BuildValue("O", variants.find(std::string(variant))->second->twoBoards ? Py_True : Py_False); } // INPUT variant, fen, move extern "C" PyObject* pyffish_getSAN(PyObject* self, PyObject *args) { PyObject* moveList = PyList_New(0); Position pos; const char *fen, *variant, *move; int chess960 = false; Notation notation = NOTATION_DEFAULT; if (!PyArg_ParseTuple(args, "sss|pi", &variant, &fen, &move, &chess960, ¬ation)) { return NULL; } if (notation == NOTATION_DEFAULT) notation = default_notation(variants.find(std::string(variant))->second); StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); std::string moveStr = move; return Py_BuildValue("s", move_to_san(pos, UCI::to_move(pos, moveStr), notation).c_str()); } // INPUT variant, fen, movelist extern "C" PyObject* pyffish_getSANmoves(PyObject* self, PyObject *args) { PyObject* sanMoves = PyList_New(0), *moveList; Position pos; const char *fen, *variant; int chess960 = false; Notation notation = NOTATION_DEFAULT; if (!PyArg_ParseTuple(args, "ssO!|pi", &variant, &fen, &PyList_Type, &moveList, &chess960, ¬ation)) { return NULL; } if (notation == NOTATION_DEFAULT) notation = default_notation(variants.find(std::string(variant))->second); StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, sanMoves, chess960); int numMoves = PyList_Size(moveList); for (int i=0; iemplace_back(); pos.do_move(m, states->back()); } else { PyErr_SetString(PyExc_ValueError, (std::string("Invalid move '") + moveStr + "'").c_str()); return NULL; } } return sanMoves; } // INPUT variant, fen, move list extern "C" PyObject* pyffish_legalMoves(PyObject* self, PyObject *args) { PyObject* legalMoves = PyList_New(0), *moveList; Position pos; const char *fen, *variant; int chess960 = false; if (!PyArg_ParseTuple(args, "ssO!|p", &variant, &fen, &PyList_Type, &moveList, &chess960)) { return NULL; } StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); for (const auto& m : MoveList(pos)) { PyObject *moveStr; moveStr = Py_BuildValue("s", UCI::move(pos, m).c_str()); PyList_Append(legalMoves, moveStr); Py_XDECREF(moveStr); } return legalMoves; } // INPUT variant, fen, move list extern "C" PyObject* pyffish_getFEN(PyObject* self, PyObject *args) { PyObject *moveList; Position pos; const char *fen, *variant; int chess960 = false, sfen = false, showPromoted = false, countStarted = 0; if (!PyArg_ParseTuple(args, "ssO!|pppi", &variant, &fen, &PyList_Type, &moveList, &chess960, &sfen, &showPromoted, &countStarted)) { return NULL; } countStarted = std::min(countStarted, INT_MAX); // pseudo-unsigned StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); return Py_BuildValue("s", pos.fen(sfen, showPromoted, countStarted).c_str()); } // INPUT variant, fen, move list extern "C" PyObject* pyffish_givesCheck(PyObject* self, PyObject *args) { PyObject *moveList; Position pos; const char *fen, *variant; int chess960 = false; if (!PyArg_ParseTuple(args, "ssO!|p", &variant, &fen, &PyList_Type, &moveList, &chess960)) { return NULL; } StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); return Py_BuildValue("O", pos.checkers() ? Py_True : Py_False); } // INPUT variant, fen, move list // should only be called when the move list is empty extern "C" PyObject* pyffish_gameResult(PyObject* self, PyObject *args) { PyObject *moveList; Position pos; const char *fen, *variant; bool gameEnd; Value result; int chess960 = false; if (!PyArg_ParseTuple(args, "ssO!|p", &variant, &fen, &PyList_Type, &moveList, &chess960)) { return NULL; } StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); assert(!MoveList(pos).size()); gameEnd = pos.is_immediate_game_end(result); if (!gameEnd) result = pos.checkers() ? pos.checkmate_value() : pos.stalemate_value(); return Py_BuildValue("i", result); } // INPUT variant, fen, move list extern "C" PyObject* pyffish_isImmediateGameEnd(PyObject* self, PyObject *args) { PyObject *moveList; Position pos; const char *fen, *variant; bool gameEnd; Value result; int chess960 = false; if (!PyArg_ParseTuple(args, "ssO!|p", &variant, &fen, &PyList_Type, &moveList, &chess960)) { return NULL; } StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); gameEnd = pos.is_immediate_game_end(result); return Py_BuildValue("(Oi)", gameEnd ? Py_True : Py_False, result); } // INPUT variant, fen, move list extern "C" PyObject* pyffish_isOptionalGameEnd(PyObject* self, PyObject *args) { PyObject *moveList; Position pos; const char *fen, *variant; bool gameEnd; Value result; int chess960 = false, countStarted = 0; if (!PyArg_ParseTuple(args, "ssO!|pi", &variant, &fen, &PyList_Type, &moveList, &chess960, &countStarted)) { return NULL; } countStarted = std::min(countStarted, INT_MAX); // pseudo-unsigned StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); gameEnd = pos.is_optional_game_end(result, 0, countStarted); return Py_BuildValue("(Oi)", gameEnd ? Py_True : Py_False, result); } // INPUT variant, fen, move list extern "C" PyObject* pyffish_hasInsufficientMaterial(PyObject* self, PyObject *args) { PyObject *moveList; Position pos; const char *fen, *variant; int chess960 = false; if (!PyArg_ParseTuple(args, "ssO!|p", &variant, &fen, &PyList_Type, &moveList, &chess960)) { return NULL; } StateListPtr states(new std::deque(1)); buildPosition(pos, states, variant, fen, moveList, chess960); bool wInsufficient = hasInsufficientMaterial(WHITE, pos); bool bInsufficient = hasInsufficientMaterial(BLACK, pos); return Py_BuildValue("(OO)", wInsufficient ? Py_True : Py_False, bInsufficient ? Py_True : Py_False); } static PyMethodDef PyFFishMethods[] = { {"info", (PyCFunction)pyffish_info, METH_NOARGS, "Get Stockfish version info."}, {"set_option", (PyCFunction)pyffish_setOption, METH_VARARGS, "Set UCI option."}, {"start_fen", (PyCFunction)pyffish_startFen, METH_VARARGS, "Get starting position FEN."}, {"two_boards", (PyCFunction)pyffish_twoBoards, METH_VARARGS, "Checks whether the variant is played on two boards."}, {"get_san", (PyCFunction)pyffish_getSAN, METH_VARARGS, "Get SAN move from given FEN and UCI move."}, {"get_san_moves", (PyCFunction)pyffish_getSANmoves, METH_VARARGS, "Get SAN movelist from given FEN and UCI movelist."}, {"legal_moves", (PyCFunction)pyffish_legalMoves, METH_VARARGS, "Get legal moves from given FEN and movelist."}, {"get_fen", (PyCFunction)pyffish_getFEN, METH_VARARGS, "Get resulting FEN from given FEN and movelist."}, {"gives_check", (PyCFunction)pyffish_givesCheck, METH_VARARGS, "Get check status from given FEN and movelist."}, {"game_result", (PyCFunction)pyffish_gameResult, METH_VARARGS, "Get result from given FEN, considering variant end, checkmate, and stalemate."}, {"is_immediate_game_end", (PyCFunction)pyffish_isImmediateGameEnd, METH_VARARGS, "Get result from given FEN if variant rules ends the game."}, {"is_optional_game_end", (PyCFunction)pyffish_isOptionalGameEnd, METH_VARARGS, "Get result from given FEN it rules enable game end by player."}, {"has_insufficient_material", (PyCFunction)pyffish_hasInsufficientMaterial, METH_VARARGS, "Checks for insufficient material."}, {NULL, NULL, 0, NULL}, // sentinel }; static PyModuleDef pyffishmodule = { PyModuleDef_HEAD_INIT, "pyffish", "Fairy-Stockfish extension module.", -1, PyFFishMethods, }; PyMODINIT_FUNC PyInit_pyffish() { PyObject* module; module = PyModule_Create(&pyffishmodule); if (module == NULL) { return NULL; } PyFFishError = PyErr_NewException("pyffish.error", NULL, NULL); Py_INCREF(PyFFishError); PyModule_AddObject(module, "error", PyFFishError); // values PyModule_AddObject(module, "VALUE_MATE", PyLong_FromLong(VALUE_MATE)); PyModule_AddObject(module, "VALUE_DRAW", PyLong_FromLong(VALUE_DRAW)); // notations PyModule_AddObject(module, "NOTATION_DEFAULT", PyLong_FromLong(NOTATION_DEFAULT)); PyModule_AddObject(module, "NOTATION_SAN", PyLong_FromLong(NOTATION_SAN)); PyModule_AddObject(module, "NOTATION_LAN", PyLong_FromLong(NOTATION_LAN)); PyModule_AddObject(module, "NOTATION_SHOGI_HOSKING", PyLong_FromLong(NOTATION_SHOGI_HOSKING)); PyModule_AddObject(module, "NOTATION_SHOGI_HODGES", PyLong_FromLong(NOTATION_SHOGI_HODGES)); PyModule_AddObject(module, "NOTATION_SHOGI_HODGES_NUMBER", PyLong_FromLong(NOTATION_SHOGI_HODGES_NUMBER)); PyModule_AddObject(module, "NOTATION_JANGGI", PyLong_FromLong(NOTATION_JANGGI)); PyModule_AddObject(module, "NOTATION_XIANGQI_WXF", PyLong_FromLong(NOTATION_XIANGQI_WXF)); // initialize stockfish pieceMap.init(); variants.init(); UCI::init(Options); PSQT::init(variants.find(Options["UCI_Variant"])->second); Bitboards::init(); Position::init(); Bitbases::init(); Search::init(); Threads.set(Options["Threads"]); Search::clear(); // After threads are up return module; }; Fairy-Stockfish-fairy_sf_11_1/src/search.cpp000066400000000000000000002203701366242550200211550ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include #include // For std::memset #include #include #include "evaluate.h" #include "misc.h" #include "movegen.h" #include "movepick.h" #include "partner.h" #include "position.h" #include "search.h" #include "thread.h" #include "timeman.h" #include "tt.h" #include "uci.h" #include "syzygy/tbprobe.h" namespace Search { LimitsType Limits; } namespace Tablebases { int Cardinality; bool RootInTB; bool UseRule50; Depth ProbeDepth; } namespace TB = Tablebases; using std::string; using Eval::evaluate; using namespace Search; namespace { // Different node types, used as a template parameter enum NodeType { NonPV, PV }; constexpr uint64_t ttHitAverageWindow = 4096; constexpr uint64_t ttHitAverageResolution = 1024; // Razor and futility margins constexpr int RazorMargin = 531; Value futility_margin(Depth d, bool improving) { return Value(217 * (d - improving)); } // Reductions lookup table, initialized at startup int Reductions[MAX_MOVES]; // [depth or moveNumber] Depth reduction(bool i, Depth d, int mn) { int r = Reductions[d] * Reductions[mn]; return (r + 511) / 1024 + (!i && r > 1007); } constexpr int futility_move_count(bool improving, Depth depth) { return (5 + depth * depth) * (1 + improving) / 2 - 1; } // History and stats update bonus, based on depth int stat_bonus(Depth d) { return d > 15 ? -8 : 19 * d * d + 155 * d - 132; } // Add a small random component to draw evaluations to avoid 3fold-blindness Value value_draw(Thread* thisThread) { return VALUE_DRAW + Value(2 * (thisThread->nodes & 1) - 1); } // Skill structure is used to implement strength limit struct Skill { explicit Skill(int l) : level(l) {} bool enabled() const { return level < 20; } bool time_to_pick(Depth depth) const { return depth == 1 + std::max(level, 0); } Move pick_best(size_t multiPV); int level; Move best = MOVE_NONE; }; // Breadcrumbs are used to mark nodes as being searched by a given thread struct Breadcrumb { std::atomic thread; std::atomic key; }; std::array breadcrumbs; // ThreadHolding structure keeps track of which thread left breadcrumbs at the given // node for potential reductions. A free node will be marked upon entering the moves // loop by the constructor, and unmarked upon leaving that loop by the destructor. struct ThreadHolding { explicit ThreadHolding(Thread* thisThread, Key posKey, int ply) { location = ply < 8 ? &breadcrumbs[posKey & (breadcrumbs.size() - 1)] : nullptr; otherThread = false; owning = false; if (location) { // See if another already marked this location, if not, mark it ourselves Thread* tmp = (*location).thread.load(std::memory_order_relaxed); if (tmp == nullptr) { (*location).thread.store(thisThread, std::memory_order_relaxed); (*location).key.store(posKey, std::memory_order_relaxed); owning = true; } else if ( tmp != thisThread && (*location).key.load(std::memory_order_relaxed) == posKey) otherThread = true; } } ~ThreadHolding() { if (owning) // Free the marked location (*location).thread.store(nullptr, std::memory_order_relaxed); } bool marked() { return otherThread; } private: Breadcrumb* location; bool otherThread, owning; }; template Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode); template Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth = 0); Value value_to_tt(Value v, int ply); Value value_from_tt(Value v, int ply, int r50c); void update_pv(Move* pv, Move move, Move* childPv); void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus); void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus); void update_all_stats(const Position& pos, Stack* ss, Move bestMove, Value bestValue, Value beta, Square prevSq, Move* quietsSearched, int quietCount, Move* capturesSearched, int captureCount, Depth depth); // perft() is our utility to verify move generation. All the leaf nodes up // to the given depth are generated and counted, and the sum is returned. template uint64_t perft(Position& pos, Depth depth) { StateInfo st; uint64_t cnt, nodes = 0; const bool leaf = (depth == 2); for (const auto& m : MoveList(pos)) { assert(pos.pseudo_legal(m)); if (Root && depth <= 1) cnt = 1, nodes++; else { pos.do_move(m, st); cnt = leaf ? MoveList(pos).size() : perft(pos, depth - 1); nodes += cnt; pos.undo_move(m); } if (Root) sync_cout << UCI::move(pos, m) << ": " << cnt << sync_endl; } return nodes; } } // namespace /// Search::init() is called at startup to initialize various lookup tables void Search::init() { for (int i = 1; i < MAX_MOVES; ++i) Reductions[i] = int((24.8 + std::log(Threads.size()) / 2) * std::log(i)); } /// Search::clear() resets search state to its initial value void Search::clear() { Threads.main()->wait_for_search_finished(); Time.availableNodes = 0; TT.clear(); Threads.clear(); Tablebases::init(Options["SyzygyPath"]); // Free mapped files } /// MainThread::search() is started when the program receives the UCI 'go' /// command. It searches from the root position and outputs the "bestmove". void MainThread::search() { if (Limits.perft) { nodes = perft(rootPos, Limits.perft); sync_cout << "\nNodes searched: " << nodes << "\n" << sync_endl; return; } Color us = rootPos.side_to_move(); Time.init(rootPos, Limits, us, rootPos.game_ply()); TT.new_search(); if (rootMoves.empty()) { rootMoves.emplace_back(MOVE_NONE); Value variantResult; Value result = rootPos.is_game_end(variantResult) ? variantResult : rootPos.checkers() ? rootPos.checkmate_value() : rootPos.stalemate_value(); if (Options["Protocol"] == "xboard") sync_cout << ( result == VALUE_DRAW ? "1/2-1/2 {Draw}" : (rootPos.side_to_move() == BLACK ? -result : result) == VALUE_MATE ? "1-0 {White wins}" : "0-1 {Black wins}") << sync_endl; else sync_cout << "info depth 0 score " << UCI::value(result) << sync_endl; } else { for (Thread* th : Threads) { th->bestMoveChanges = 0; if (th != this) th->start_searching(); } Thread::search(); // Let's start searching! } if (rootPos.two_boards() && !Threads.abort && Options["Protocol"] == "xboard") { while (!Threads.stop && (Partner.sitRequested || Partner.weDead) && Time.elapsed() < Limits.time[us] - 1000) {} } // When we reach the maximum depth, we can arrive here without a raise of // Threads.stop. However, if we are pondering or in an infinite search, // the UCI protocol states that we shouldn't print the best move before the // GUI sends a "stop" or "ponderhit" command. We therefore simply wait here // until the GUI sends one of those commands. while (!Threads.stop && (ponder || Limits.infinite)) {} // Busy wait for a stop or a ponder reset // Stop the threads if not already stopped (also raise the stop if // "ponderhit" just reset Threads.ponder). Threads.stop = true; // Wait until all threads have finished for (Thread* th : Threads) if (th != this) th->wait_for_search_finished(); // When playing in 'nodes as time' mode, subtract the searched nodes from // the available ones before exiting. if (Limits.npmsec) Time.availableNodes += Limits.inc[us] - Threads.nodes_searched(); bestThread = this; // Check if there are threads with a better score than main thread if ( Options["MultiPV"] == 1 && !Limits.depth && !(Skill(Options["Skill Level"]).enabled() || Options["UCI_LimitStrength"]) && rootMoves[0].pv[0] != MOVE_NONE) { std::map votes; Value minScore = this->rootMoves[0].score; // Find out minimum score for (Thread* th: Threads) minScore = std::min(minScore, th->rootMoves[0].score); // Vote according to score and depth, and select the best thread for (Thread* th : Threads) { votes[th->rootMoves[0].pv[0]] += (th->rootMoves[0].score - minScore + 14) * int(th->completedDepth); if (bestThread->rootMoves[0].score >= VALUE_MATE_IN_MAX_PLY) { // Make sure we pick the shortest mate if (th->rootMoves[0].score > bestThread->rootMoves[0].score) bestThread = th; } else if ( th->rootMoves[0].score >= VALUE_MATE_IN_MAX_PLY || votes[th->rootMoves[0].pv[0]] > votes[bestThread->rootMoves[0].pv[0]]) bestThread = th; } } previousScore = bestThread->rootMoves[0].score; // Send again PV info if we have a new best thread if (bestThread != this) sync_cout << UCI::pv(bestThread->rootPos, bestThread->completedDepth, -VALUE_INFINITE, VALUE_INFINITE) << sync_endl; if (Options["Protocol"] == "xboard") { // Send move only when not in analyze mode and not at game end if (!Options["UCI_AnalyseMode"] && rootMoves[0].pv[0] != MOVE_NONE && !Threads.abort.exchange(true)) sync_cout << "move " << UCI::move(rootPos, bestThread->rootMoves[0].pv[0]) << sync_endl; return; } sync_cout << "bestmove " << UCI::move(rootPos, bestThread->rootMoves[0].pv[0]); if (bestThread->rootMoves[0].pv.size() > 1 || bestThread->rootMoves[0].extract_ponder_from_tt(rootPos)) std::cout << " ponder " << UCI::move(rootPos, bestThread->rootMoves[0].pv[1]); std::cout << sync_endl; } /// Thread::search() is the main iterative deepening loop. It calls search() /// repeatedly with increasing depth until the allocated thinking time has been /// consumed, the user stops the search, or the maximum search depth is reached. void Thread::search() { // To allow access to (ss-7) up to (ss+2), the stack must be oversized. // The former is needed to allow update_continuation_histories(ss-1, ...), // which accesses its argument at ss-6, also near the root. // The latter is needed for statScores and killer initialization. Stack stack[MAX_PLY+10], *ss = stack+7; Move pv[MAX_PLY+1]; Value bestValue, alpha, beta, delta; Move lastBestMove = MOVE_NONE; Depth lastBestMoveDepth = 0; MainThread* mainThread = (this == Threads.main() ? Threads.main() : nullptr); double timeReduction = 1, totBestMoveChanges = 0; Color us = rootPos.side_to_move(); int iterIdx = 0; std::memset(ss-7, 0, 10 * sizeof(Stack)); for (int i = 7; i > 0; i--) (ss-i)->continuationHistory = &this->continuationHistory[0][0][NO_PIECE][0]; // Use as a sentinel ss->pv = pv; bestValue = delta = alpha = -VALUE_INFINITE; beta = VALUE_INFINITE; if (mainThread) { if (mainThread->previousScore == VALUE_INFINITE) for (int i=0; i<4; ++i) mainThread->iterValue[i] = VALUE_ZERO; else for (int i=0; i<4; ++i) mainThread->iterValue[i] = mainThread->previousScore; } size_t multiPV = Options["MultiPV"]; // Pick integer skill levels, but non-deterministically round up or down // such that the average integer skill corresponds to the input floating point one. // UCI_Elo is converted to a suitable fractional skill level, using anchoring // to CCRL Elo (goldfish 1.13 = 2000) and a fit through Ordo derived Elo // for match (TC 60+0.6) results spanning a wide range of k values. PRNG rng(now()); double floatLevel = Options["UCI_LimitStrength"] ? clamp(std::pow((Options["UCI_Elo"] - 1346.6) / 143.4, 1 / 0.806), 0.0, 20.0) : double(Options["Skill Level"]); int intLevel = int(floatLevel) + ((floatLevel - int(floatLevel)) * 1024 > rng.rand() % 1024 ? 1 : 0); Skill skill(intLevel); // When playing with strength handicap enable MultiPV search that we will // use behind the scenes to retrieve a set of possible moves. if (skill.enabled()) multiPV = std::max(multiPV, (size_t)4); multiPV = std::min(multiPV, rootMoves.size()); ttHitAverage = ttHitAverageWindow * ttHitAverageResolution / 2; int ct = int(Options["Contempt"]) * PawnValueEg / 100; // From centipawns // In analysis mode, adjust contempt in accordance with user preference if (Limits.infinite || Options["UCI_AnalyseMode"]) ct = Options["Analysis Contempt"] == "Off" ? 0 : Options["Analysis Contempt"] == "Both" ? ct : Options["Analysis Contempt"] == "White" && us == BLACK ? -ct : Options["Analysis Contempt"] == "Black" && us == WHITE ? -ct : ct; // Evaluation score is from the white point of view contempt = (us == WHITE ? make_score(ct, ct / 2) : -make_score(ct, ct / 2)); int searchAgainCounter = 0; // Iterative deepening loop until requested to stop or the target depth is reached while ( ++rootDepth < MAX_PLY && !Threads.stop && !(Limits.depth && mainThread && rootDepth > Limits.depth)) { // Age out PV variability metric if (mainThread) totBestMoveChanges /= 2; // Save the last iteration's scores before first PV line is searched and // all the move scores except the (new) PV are set to -VALUE_INFINITE. for (RootMove& rm : rootMoves) rm.previousScore = rm.score; size_t pvFirst = 0; pvLast = 0; if (!Threads.increaseDepth) searchAgainCounter++; // MultiPV loop. We perform a full root search for each PV line for (pvIdx = 0; pvIdx < multiPV && !Threads.stop; ++pvIdx) { if (pvIdx == pvLast) { pvFirst = pvLast; for (pvLast++; pvLast < rootMoves.size(); pvLast++) if (rootMoves[pvLast].tbRank != rootMoves[pvFirst].tbRank) break; } // Reset UCI info selDepth for each depth and each PV line selDepth = 0; // Reset aspiration window starting size if (rootDepth >= 4) { Value previousScore = rootMoves[pvIdx].previousScore; delta = Value(21 * (1 + rootPos.captures_to_hand()) + abs(previousScore) / 256); alpha = std::max(previousScore - delta,-VALUE_INFINITE); beta = std::min(previousScore + delta, VALUE_INFINITE); // Adjust contempt based on root move's previousScore (dynamic contempt) int dct = ct + (102 - ct / 2) * previousScore / (abs(previousScore) + 157); contempt = (us == WHITE ? make_score(dct, dct / 2) : -make_score(dct, dct / 2)); } // Start with a small aspiration window and, in the case of a fail // high/low, re-search with a bigger window until we don't fail // high/low anymore. int failedHighCnt = 0; while (true) { Depth adjustedDepth = std::max(1, rootDepth - failedHighCnt - searchAgainCounter); bestValue = ::search(rootPos, ss, alpha, beta, adjustedDepth, false); // Bring the best move to the front. It is critical that sorting // is done with a stable algorithm because all the values but the // first and eventually the new best one are set to -VALUE_INFINITE // and we want to keep the same order for all the moves except the // new PV that goes to the front. Note that in case of MultiPV // search the already searched PV lines are preserved. std::stable_sort(rootMoves.begin() + pvIdx, rootMoves.begin() + pvLast); // If search has been stopped, we break immediately. Sorting is // safe because RootMoves is still valid, although it refers to // the previous iteration. if (Threads.stop) break; // When failing high/low give some update (without cluttering // the UI) before a re-search. if ( mainThread && multiPV == 1 && (bestValue <= alpha || bestValue >= beta) && Time.elapsed() > 3000) sync_cout << UCI::pv(rootPos, rootDepth, alpha, beta) << sync_endl; // In case of failing low/high increase aspiration window and // re-search, otherwise exit the loop. if (bestValue <= alpha) { beta = (alpha + beta) / 2; alpha = std::max(bestValue - delta, -VALUE_INFINITE); failedHighCnt = 0; if (mainThread) mainThread->stopOnPonderhit = false; } else if (bestValue >= beta) { beta = std::min(bestValue + delta, VALUE_INFINITE); ++failedHighCnt; } else { ++rootMoves[pvIdx].bestMoveCount; break; } delta += delta / 4 + 5; assert(alpha >= -VALUE_INFINITE && beta <= VALUE_INFINITE); } // Sort the PV lines searched so far and update the GUI std::stable_sort(rootMoves.begin() + pvFirst, rootMoves.begin() + pvIdx + 1); if ( mainThread && (Threads.stop || pvIdx + 1 == multiPV || Time.elapsed() > 3000)) sync_cout << UCI::pv(rootPos, rootDepth, alpha, beta) << sync_endl; } if (!Threads.stop) completedDepth = rootDepth; if (rootMoves[0].pv[0] != lastBestMove) { lastBestMove = rootMoves[0].pv[0]; lastBestMoveDepth = rootDepth; } // Have we found a "mate in x"? if ( Limits.mate && bestValue >= VALUE_MATE_IN_MAX_PLY && VALUE_MATE - bestValue <= 2 * Limits.mate) Threads.stop = true; if (!mainThread) continue; // If skill level is enabled and time is up, pick a sub-optimal best move if (skill.enabled() && skill.time_to_pick(rootDepth)) skill.pick_best(multiPV); // Do we have time for the next iteration? Can we stop searching now? if ( Limits.use_time_management() && !Threads.stop && !mainThread->stopOnPonderhit) { double fallingEval = (332 + 6 * (mainThread->previousScore - bestValue) + 6 * (mainThread->iterValue[iterIdx] - bestValue)) / 704.0; fallingEval = clamp(fallingEval, 0.5, 1.5); // If the bestMove is stable over several iterations, reduce time accordingly timeReduction = lastBestMoveDepth + 9 < completedDepth ? 1.94 : 0.91; double reduction = (1.41 + mainThread->previousTimeReduction) / (2.27 * timeReduction); // Use part of the gained time from a previous stable move for the current move for (Thread* th : Threads) { totBestMoveChanges += th->bestMoveChanges; th->bestMoveChanges = 0; } double bestMoveInstability = 1 + totBestMoveChanges / Threads.size(); if (completedDepth >= 8 && rootPos.two_boards() && Options["Protocol"] == "xboard") { if (Limits.time[us]) Partner.ptell("time " + std::to_string((Limits.time[us] - Time.elapsed()) / 10)); if (Limits.time[~us]) Partner.ptell("otim " + std::to_string(Limits.time[~us] / 10)); if (!Partner.weDead && bestValue <= VALUE_MATED_IN_MAX_PLY) { Partner.ptell("dead"); Partner.weDead = true; } else if (Partner.weDead && bestValue > VALUE_MATED_IN_MAX_PLY) { Partner.ptell("x"); Partner.weDead = false; } else if (!Partner.weWin && bestValue >= VALUE_MATE_IN_MAX_PLY && Limits.time[~us] < Partner.time * 10) { Partner.ptell("sit"); Partner.weWin = true; } else if (Partner.weWin && (bestValue < VALUE_MATE_IN_MAX_PLY || Limits.time[~us] > Partner.time * 10)) { Partner.ptell("x"); Partner.weWin = false; } } // Stop the search if we have only one legal move, or if available time elapsed if ( rootMoves.size() == 1 || Time.elapsed() > Time.optimum() * fallingEval * reduction * bestMoveInstability) { // If we are allowed to ponder do not stop the search now but // keep pondering until the GUI sends "ponderhit" or "stop". if (mainThread->ponder) mainThread->stopOnPonderhit = true; else if (!(rootPos.two_boards() && (Partner.sitRequested || Partner.weDead))) Threads.stop = true; } else if ( Threads.increaseDepth && !mainThread->ponder && Time.elapsed() > Time.optimum() * fallingEval * reduction * bestMoveInstability * 0.6) Threads.increaseDepth = false; else Threads.increaseDepth = true; } mainThread->iterValue[iterIdx] = bestValue; iterIdx = (iterIdx + 1) & 3; } if (!mainThread) return; mainThread->previousTimeReduction = timeReduction; // If skill level is enabled, swap best PV line with the sub-optimal one if (skill.enabled()) std::swap(rootMoves[0], *std::find(rootMoves.begin(), rootMoves.end(), skill.best ? skill.best : skill.pick_best(multiPV))); } namespace { // search<>() is the main search function for both PV and non-PV nodes template Value search(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth, bool cutNode) { constexpr bool PvNode = NT == PV; const bool rootNode = PvNode && ss->ply == 0; // Check if we have an upcoming move which draws by repetition, or // if the opponent had an alternative move earlier to this position. if ( pos.rule50_count() >= 3 && alpha < VALUE_DRAW && !rootNode && pos.has_game_cycle(ss->ply)) { alpha = value_draw(pos.this_thread()); if (alpha >= beta) return alpha; } // Dive into quiescence search when the depth reaches zero if (depth <= 0) return qsearch(pos, ss, alpha, beta); assert(-VALUE_INFINITE <= alpha && alpha < beta && beta <= VALUE_INFINITE); assert(PvNode || (alpha == beta - 1)); assert(0 < depth && depth < MAX_PLY); assert(!(PvNode && cutNode)); Move pv[MAX_PLY+1], capturesSearched[32], quietsSearched[64]; StateInfo st; TTEntry* tte; Key posKey; Move ttMove, move, excludedMove, bestMove; Depth extension, newDepth; Value bestValue, value, ttValue, eval, maxValue; bool ttHit, ttPv, inCheck, givesCheck, improving, didLMR, priorCapture; bool captureOrPromotion, doFullDepthSearch, moveCountPruning, ttCapture, singularLMR; Piece movedPiece; int moveCount, captureCount, quietCount; // Step 1. Initialize node Thread* thisThread = pos.this_thread(); inCheck = pos.checkers(); priorCapture = pos.captured_piece(); Color us = pos.side_to_move(); moveCount = captureCount = quietCount = ss->moveCount = 0; bestValue = -VALUE_INFINITE; maxValue = VALUE_INFINITE; // Check for the available remaining time if (thisThread == Threads.main()) static_cast(thisThread)->check_time(); // Used to send selDepth info to GUI (selDepth counts from 1, ply from 0) if (PvNode && thisThread->selDepth < ss->ply + 1) thisThread->selDepth = ss->ply + 1; if (!rootNode) { Value variantResult; if (pos.is_game_end(variantResult, ss->ply)) return variantResult; // Step 2. Check for aborted search and immediate draw if ( Threads.stop.load(std::memory_order_relaxed) || ss->ply >= MAX_PLY) return (ss->ply >= MAX_PLY && !inCheck) ? evaluate(pos) : value_draw(pos.this_thread()); // Step 3. Mate distance pruning. Even if we mate at the next move our score // would be at best mate_in(ss->ply+1), but if alpha is already bigger because // a shorter mate was found upward in the tree then there is no need to search // because we will never beat the current alpha. Same logic but with reversed // signs applies also in the opposite condition of being mated instead of giving // mate. In this case return a fail-high score. alpha = std::max(mated_in(ss->ply), alpha); beta = std::min(mate_in(ss->ply+1), beta); if (alpha >= beta) return alpha; } assert(0 <= ss->ply && ss->ply < MAX_PLY); (ss+1)->ply = ss->ply + 1; (ss+1)->excludedMove = bestMove = MOVE_NONE; (ss+2)->killers[0] = (ss+2)->killers[1] = MOVE_NONE; Square prevSq = to_sq((ss-1)->currentMove); // Initialize statScore to zero for the grandchildren of the current position. // So statScore is shared between all grandchildren and only the first grandchild // starts with statScore = 0. Later grandchildren start with the last calculated // statScore of the previous grandchild. This influences the reduction rules in // LMR which are based on the statScore of parent position. if (rootNode) (ss+4)->statScore = 0; else (ss+2)->statScore = 0; // Step 4. Transposition table lookup. We don't want the score of a partial // search to overwrite a previous full search TT value, so we use a different // position key in case of an excluded move. excludedMove = ss->excludedMove; posKey = pos.key() ^ (Key(excludedMove) << 16); // Isn't a very good hash tte = TT.probe(posKey, ttHit); ttValue = ttHit ? value_from_tt(tte->value(), ss->ply, pos.rule50_count()) : VALUE_NONE; ttMove = rootNode ? thisThread->rootMoves[thisThread->pvIdx].pv[0] : ttHit ? tte->move() : MOVE_NONE; ttPv = PvNode || (ttHit && tte->is_pv()); // thisThread->ttHitAverage can be used to approximate the running average of ttHit thisThread->ttHitAverage = (ttHitAverageWindow - 1) * thisThread->ttHitAverage / ttHitAverageWindow + ttHitAverageResolution * ttHit; // At non-PV nodes we check for an early TT cutoff if ( !PvNode && ttHit && tte->depth() >= depth && ttValue != VALUE_NONE // Possible in case of TT access race && (ttValue >= beta ? (tte->bound() & BOUND_LOWER) : (tte->bound() & BOUND_UPPER))) { // If ttMove is quiet, update move sorting heuristics on TT hit if (ttMove) { if (ttValue >= beta) { if (!pos.capture_or_promotion(ttMove)) update_quiet_stats(pos, ss, ttMove, stat_bonus(depth)); // Extra penalty for early quiet moves of the previous ply if ((ss-1)->moveCount <= 2 && !priorCapture) update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -stat_bonus(depth + 1)); } // Penalty for a quiet ttMove that fails low else if (!pos.capture_or_promotion(ttMove)) { int penalty = -stat_bonus(depth); thisThread->mainHistory[us][from_to(ttMove)] << penalty; update_continuation_histories(ss, pos.moved_piece(ttMove), to_sq(ttMove), penalty); } } if (pos.rule50_count() < 90) return ttValue; } // Step 5. Tablebases probe if (!rootNode && TB::Cardinality) { int piecesCount = pos.count(); if ( piecesCount <= TB::Cardinality && (piecesCount < TB::Cardinality || depth >= TB::ProbeDepth) && pos.rule50_count() == 0 && Options["UCI_Variant"] == "chess" && !pos.can_castle(ANY_CASTLING)) { TB::ProbeState err; TB::WDLScore wdl = Tablebases::probe_wdl(pos, &err); // Force check of time on the next occasion if (thisThread == Threads.main()) static_cast(thisThread)->callsCnt = 0; if (err != TB::ProbeState::FAIL) { thisThread->tbHits.fetch_add(1, std::memory_order_relaxed); int drawScore = TB::UseRule50 ? 1 : 0; value = wdl < -drawScore ? -VALUE_MATE + MAX_PLY + ss->ply + 1 : wdl > drawScore ? VALUE_MATE - MAX_PLY - ss->ply - 1 : VALUE_DRAW + 2 * wdl * drawScore; Bound b = wdl < -drawScore ? BOUND_UPPER : wdl > drawScore ? BOUND_LOWER : BOUND_EXACT; if ( b == BOUND_EXACT || (b == BOUND_LOWER ? value >= beta : value <= alpha)) { tte->save(posKey, value_to_tt(value, ss->ply), ttPv, b, std::min(MAX_PLY - 1, depth + 6), MOVE_NONE, VALUE_NONE); return value; } if (PvNode) { if (b == BOUND_LOWER) bestValue = value, alpha = std::max(alpha, bestValue); else maxValue = value; } } } } // Step 6. Static evaluation of the position if (inCheck) { ss->staticEval = eval = VALUE_NONE; improving = false; goto moves_loop; // Skip early pruning when in check } else if (ttHit) { // Never assume anything about values stored in TT ss->staticEval = eval = tte->eval(); if (eval == VALUE_NONE) ss->staticEval = eval = evaluate(pos); if (eval == VALUE_DRAW) eval = value_draw(thisThread); // Can ttValue be used as a better position evaluation? if ( ttValue != VALUE_NONE && (tte->bound() & (ttValue > eval ? BOUND_LOWER : BOUND_UPPER))) eval = ttValue; } else { if ((ss-1)->currentMove != MOVE_NULL) { int bonus = -(ss-1)->statScore / 512; ss->staticEval = eval = evaluate(pos) + bonus; } else ss->staticEval = eval = -(ss-1)->staticEval + 2 * Eval::tempo_value(pos); tte->save(posKey, VALUE_NONE, ttPv, BOUND_NONE, DEPTH_NONE, MOVE_NONE, eval); } // Step 7. Razoring (~1 Elo) if ( !rootNode // The required rootNode PV handling is not available in qsearch && depth < 2 && !pos.must_capture() && !pos.capture_the_flag_piece() && !pos.check_counting() && eval <= alpha - RazorMargin) return qsearch(pos, ss, alpha, beta); improving = (ss-2)->staticEval == VALUE_NONE ? (ss->staticEval >= (ss-4)->staticEval || (ss-4)->staticEval == VALUE_NONE) : ss->staticEval >= (ss-2)->staticEval; // Skip early pruning in case of mandatory capture if (pos.must_capture() && MoveList(pos).size()) goto moves_loop; // Step 8. Futility pruning: child node (~50 Elo) if ( !PvNode && depth < 6 && !( pos.extinction_value() == -VALUE_MATE && pos.extinction_piece_types().find(ALL_PIECES) == pos.extinction_piece_types().end()) && (pos.checking_permitted() || !pos.capture_the_flag_piece()) && eval - futility_margin(depth, improving) * (1 + pos.check_counting()) >= beta && eval < VALUE_KNOWN_WIN) // Do not return unproven wins return eval; // Step 9. Null move search with verification search (~40 Elo) if ( !PvNode && (ss-1)->currentMove != MOVE_NULL && (ss-1)->statScore < 23397 && eval >= beta && eval >= ss->staticEval && ss->staticEval >= beta - 32 * depth + 292 - improving * 30 && !excludedMove && pos.non_pawn_material(us) && (pos.pieces(~us) ^ pos.pieces(~us, PAWN)) && (pos.pieces() ^ pos.pieces(BREAKTHROUGH_PIECE) ^ pos.pieces(CLOBBER_PIECE)) && (ss->ply >= thisThread->nmpMinPly || us != thisThread->nmpColor)) { assert(eval - beta >= 0); // Null move dynamic reduction based on depth and value Depth R = (854 - 150 * !pos.checking_permitted() + 68 * depth) / 258 + std::min(int(eval - beta) / 192, 3); ss->currentMove = MOVE_NULL; ss->continuationHistory = &thisThread->continuationHistory[0][0][NO_PIECE][0]; pos.do_null_move(st); Value nullValue = -search(pos, ss+1, -beta, -beta+1, depth-R, !cutNode); pos.undo_null_move(); if (nullValue >= beta) { // Do not return unproven mate scores if (nullValue >= VALUE_MATE_IN_MAX_PLY) nullValue = beta; if (thisThread->nmpMinPly || (abs(beta) < VALUE_KNOWN_WIN && depth < 13)) return nullValue; assert(!thisThread->nmpMinPly); // Recursive verification is not allowed // Do verification search at high depths, with null move pruning disabled // for us, until ply exceeds nmpMinPly. thisThread->nmpMinPly = ss->ply + 3 * (depth-R) / 4; thisThread->nmpColor = us; Value v = search(pos, ss, beta-1, beta, depth-R, false); thisThread->nmpMinPly = 0; if (v >= beta) return nullValue; } } // Step 10. ProbCut (~10 Elo) // If we have a good enough capture and a reduced search returns a value // much above beta, we can (almost) safely prune the previous move. if ( !PvNode && depth >= 5 && (pos.pieces() ^ pos.pieces(CLOBBER_PIECE)) && abs(beta) < VALUE_MATE_IN_MAX_PLY) { Value raisedBeta = std::min(beta + (189 + 20 * !!pos.capture_the_flag_piece()) * (1 + pos.check_counting() + (pos.extinction_value() != VALUE_NONE)) - 45 * improving, VALUE_INFINITE); MovePicker mp(pos, ttMove, raisedBeta - ss->staticEval, &thisThread->captureHistory); int probCutCount = 0; while ( (move = mp.next_move()) != MOVE_NONE && probCutCount < 2 + 2 * cutNode) if (move != excludedMove && pos.legal(move)) { assert(pos.capture_or_promotion(move)); assert(depth >= 5); captureOrPromotion = true; probCutCount++; ss->currentMove = move; ss->continuationHistory = &thisThread->continuationHistory[inCheck] [captureOrPromotion] [history_slot(pos.moved_piece(move))] [to_sq(move)]; pos.do_move(move, st); // Perform a preliminary qsearch to verify that the move holds value = -qsearch(pos, ss+1, -raisedBeta, -raisedBeta+1); // If the qsearch held, perform the regular search if (value >= raisedBeta) value = -search(pos, ss+1, -raisedBeta, -raisedBeta+1, depth - 4, !cutNode); pos.undo_move(move); if (value >= raisedBeta) return value; } } // Step 11. Internal iterative deepening (~1 Elo) if (depth >= (7 - 2 * pos.captures_to_hand()) && !ttMove) { search(pos, ss, alpha, beta, depth - (7 - 2 * pos.captures_to_hand()), cutNode); tte = TT.probe(posKey, ttHit); ttValue = ttHit ? value_from_tt(tte->value(), ss->ply, pos.rule50_count()) : VALUE_NONE; ttMove = ttHit ? tte->move() : MOVE_NONE; } moves_loop: // When in check, search starts from here const PieceToHistory* contHist[] = { (ss-1)->continuationHistory, (ss-2)->continuationHistory, nullptr , (ss-4)->continuationHistory, nullptr , (ss-6)->continuationHistory }; Move countermove = thisThread->counterMoves[pos.piece_on(prevSq)][prevSq]; MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory, &thisThread->captureHistory, contHist, countermove, ss->killers); value = bestValue; singularLMR = moveCountPruning = false; ttCapture = ttMove && pos.capture_or_promotion(ttMove); // Mark this node as being searched ThreadHolding th(thisThread, posKey, ss->ply); // Step 12. Loop through all pseudo-legal moves until no moves remain // or a beta cutoff occurs. while ((move = mp.next_move(moveCountPruning)) != MOVE_NONE) { assert(is_ok(move)); if (move == excludedMove) continue; // At root obey the "searchmoves" option and skip moves not listed in Root // Move List. As a consequence any illegal move is also skipped. In MultiPV // mode we also skip PV moves which have been already searched and those // of lower "TB rank" if we are in a TB root position. if (rootNode && !std::count(thisThread->rootMoves.begin() + thisThread->pvIdx, thisThread->rootMoves.begin() + thisThread->pvLast, move)) continue; ss->moveCount = ++moveCount; if (rootNode && thisThread == Threads.main() && Time.elapsed() > 3000 && Options["Protocol"] != "xboard") sync_cout << "info depth " << depth << " currmove " << UCI::move(pos, move) << " currmovenumber " << moveCount + thisThread->pvIdx << sync_endl; if (PvNode) (ss+1)->pv = nullptr; extension = 0; captureOrPromotion = pos.capture_or_promotion(move); movedPiece = pos.moved_piece(move); givesCheck = pos.gives_check(move); // Calculate new depth for this move newDepth = depth - 1; // Step 13. Pruning at shallow depth (~200 Elo) if ( !rootNode && (pos.non_pawn_material(us) || !(pos.pieces(us) ^ pos.pieces(us, PAWN))) && bestValue > VALUE_MATED_IN_MAX_PLY) { // Skip quiet moves if movecount exceeds our FutilityMoveCount threshold moveCountPruning = moveCount >= futility_move_count(improving, depth) || (pos.must_capture() && (moveCountPruning || (pos.capture(move) && pos.legal(move)))); if ( !captureOrPromotion && !givesCheck && (!pos.must_capture() || !pos.attackers_to(to_sq(move), ~us))) { // Reduced depth of the next LMR search int lmrDepth = std::max(newDepth - reduction(improving, depth, moveCount), 0); // Countermoves based pruning (~20 Elo) if ( lmrDepth < 4 + ((ss-1)->statScore > 0 || (ss-1)->moveCount == 1) && (*contHist[0])[history_slot(movedPiece)][to_sq(move)] < CounterMovePruneThreshold && (*contHist[1])[history_slot(movedPiece)][to_sq(move)] < CounterMovePruneThreshold) continue; // Futility pruning: parent node (~5 Elo) if ( lmrDepth < 6 && !inCheck && !( pos.extinction_value() == -VALUE_MATE && pos.extinction_piece_types().find(ALL_PIECES) == pos.extinction_piece_types().end()) && ss->staticEval + 235 + 172 * lmrDepth <= alpha && thisThread->mainHistory[us][from_to(move)] + (*contHist[0])[history_slot(movedPiece)][to_sq(move)] + (*contHist[1])[history_slot(movedPiece)][to_sq(move)] + (*contHist[3])[history_slot(movedPiece)][to_sq(move)] < 25000) continue; // Prune moves with negative SEE (~20 Elo) if (!pos.must_capture() && !pos.see_ge(move, Value(-(32 - std::min(lmrDepth, 18)) * lmrDepth * lmrDepth))) continue; } else if ( !pos.must_capture() && !pos.see_ge(move, Value(-194 - 120 * pos.captures_to_hand()) * depth)) // (~25 Elo) continue; } // Step 14. Extensions (~75 Elo) // Singular extension search (~70 Elo). If all moves but one fail low on a // search of (alpha-s, beta-s), and just one fails high on (alpha, beta), // then that move is singular and should be extended. To verify this we do // a reduced search on all the other moves but the ttMove and if the // result is lower than ttValue minus a margin then we will extend the ttMove. if ( depth >= 6 && move == ttMove && !rootNode && !excludedMove // Avoid recursive singular search /* && ttValue != VALUE_NONE Already implicit in the next condition */ && abs(ttValue) < VALUE_KNOWN_WIN && (tte->bound() & BOUND_LOWER) && tte->depth() >= depth - 3 && pos.legal(move)) { Value singularBeta = ttValue - 2 * depth; Depth halfDepth = depth / 2; ss->excludedMove = move; value = search(pos, ss, singularBeta - 1, singularBeta, halfDepth, cutNode); ss->excludedMove = MOVE_NONE; if (value < singularBeta) { extension = 1; singularLMR = true; } // Multi-cut pruning // Our ttMove is assumed to fail high, and now we failed high also on a reduced // search without the ttMove. So we assume this expected Cut-node is not singular, // that multiple moves fail high, and we can prune the whole subtree by returning // a soft bound. else if (singularBeta >= beta) return singularBeta; } // Check extension (~2 Elo) else if ( givesCheck && (pos.is_discovery_check_on_king(~us, move) || pos.see_ge(move))) extension = 1; // Passed pawn extension else if ( move == ss->killers[0] && pos.advanced_pawn_push(move) && pos.pawn_passed(us, to_sq(move))) extension = 1; // Last captures extension else if ( PieceValue[EG][pos.captured_piece()] > PawnValueEg && pos.non_pawn_material() <= 2 * RookValueMg) extension = 1; // Castling extension if (type_of(move) == CASTLING) extension = 1; // Losing chess capture extension else if ( pos.must_capture() && pos.capture(move) && MoveList(pos).size() == 1) extension = 1; // Add extension to new depth newDepth += extension; // Speculative prefetch as early as possible prefetch(TT.first_entry(pos.key_after(move))); // Check for legality just before making the move if (!rootNode && !pos.legal(move)) { ss->moveCount = --moveCount; continue; } // Update the current move (this must be done after singular extension search) ss->currentMove = move; ss->continuationHistory = &thisThread->continuationHistory[inCheck] [captureOrPromotion] [history_slot(movedPiece)] [to_sq(move)]; // Step 15. Make the move pos.do_move(move, st, givesCheck); // Step 16. Reduced depth search (LMR, ~200 Elo). If the move fails high it will be // re-searched at full depth. if ( depth >= 3 && moveCount > 1 + rootNode + (rootNode && bestValue < alpha) && (!rootNode || thisThread->best_move_count(move) == 0) && ( !captureOrPromotion || moveCountPruning || ss->staticEval + PieceValue[EG][pos.captured_piece()] <= alpha || cutNode || thisThread->ttHitAverage < 375 * ttHitAverageResolution * ttHitAverageWindow / 1024) && !(pos.must_capture() && MoveList(pos).size())) { Depth r = reduction(improving, depth, moveCount); // Decrease reduction if the ttHit running average is large if (thisThread->ttHitAverage > 500 * ttHitAverageResolution * ttHitAverageWindow / 1024) r--; // Reduction if other threads are searching this position. if (th.marked()) r++; // Decrease reduction if position is or has been on the PV (~10 Elo) if (ttPv) r -= 2; // Decrease reduction if opponent's move count is high (~5 Elo) if ((ss-1)->moveCount > 14) r--; // Decrease reduction if ttMove has been singularly extended (~3 Elo) if (singularLMR) r -= 2; if (!captureOrPromotion && !(pos.must_capture() && MoveList(pos).size())) { // Increase reduction if ttMove is a capture (~5 Elo) if (ttCapture) r++; // Increase reduction for cut nodes (~10 Elo) if (cutNode) r += 2; // Decrease reduction for moves that escape a capture. Filter out // castling moves, because they are coded as "king captures rook" and // hence break make_move(). (~2 Elo) else if ( type_of(move) == NORMAL && !pos.see_ge(reverse_move(move))) r -= 2; ss->statScore = thisThread->mainHistory[us][from_to(move)] + (*contHist[0])[history_slot(movedPiece)][to_sq(move)] + (*contHist[1])[history_slot(movedPiece)][to_sq(move)] + (*contHist[3])[history_slot(movedPiece)][to_sq(move)] - 4926; // Reset statScore to zero if negative and most stats shows >= 0 if ( ss->statScore < 0 && (*contHist[0])[history_slot(movedPiece)][to_sq(move)] >= 0 && (*contHist[1])[history_slot(movedPiece)][to_sq(move)] >= 0 && thisThread->mainHistory[us][from_to(move)] >= 0) ss->statScore = 0; // Decrease/increase reduction by comparing opponent's stat score (~10 Elo) if (ss->statScore >= -102 && (ss-1)->statScore < -114) r--; else if ((ss-1)->statScore >= -116 && ss->statScore < -154) r++; // Decrease/increase reduction for moves with a good/bad history (~30 Elo) r -= ss->statScore / 16384; } // Increase reduction for captures/promotions if late move and at low depth else if (depth < 8 && moveCount > 2) r++; Depth d = clamp(newDepth - r, 1, newDepth); value = -search(pos, ss+1, -(alpha+1), -alpha, d, true); doFullDepthSearch = (value > alpha && d != newDepth), didLMR = true; } else doFullDepthSearch = !PvNode || moveCount > 1, didLMR = false; // Step 17. Full depth search when LMR is skipped or fails high if (doFullDepthSearch) { value = -search(pos, ss+1, -(alpha+1), -alpha, newDepth, !cutNode); if (didLMR && !captureOrPromotion) { int bonus = value > alpha ? stat_bonus(newDepth) : -stat_bonus(newDepth); if (move == ss->killers[0]) bonus += bonus / 4; update_continuation_histories(ss, movedPiece, to_sq(move), bonus); } } // For PV nodes only, do a full PV search on the first move or after a fail // high (in the latter case search only if value < beta), otherwise let the // parent node fail low with value <= alpha and try another move. if (PvNode && (moveCount == 1 || (value > alpha && (rootNode || value < beta)))) { (ss+1)->pv = pv; (ss+1)->pv[0] = MOVE_NONE; value = -search(pos, ss+1, -beta, -alpha, newDepth, false); } // Step 18. Undo move pos.undo_move(move); assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); // Step 19. Check for a new best move // Finished searching the move. If a stop occurred, the return value of // the search cannot be trusted, and we return immediately without // updating best move, PV and TT. if (Threads.stop.load(std::memory_order_relaxed)) return VALUE_ZERO; if (rootNode) { RootMove& rm = *std::find(thisThread->rootMoves.begin(), thisThread->rootMoves.end(), move); // PV move or new best move? if (moveCount == 1 || value > alpha) { rm.score = value; rm.selDepth = thisThread->selDepth; rm.pv.resize(1); assert((ss+1)->pv); for (Move* m = (ss+1)->pv; *m != MOVE_NONE; ++m) rm.pv.push_back(*m); // We record how often the best move has been changed in each // iteration. This information is used for time management: When // the best move changes frequently, we allocate some more time. if (moveCount > 1) ++thisThread->bestMoveChanges; } else // All other moves but the PV are set to the lowest value: this // is not a problem when sorting because the sort is stable and the // move position in the list is preserved - just the PV is pushed up. rm.score = -VALUE_INFINITE; } if (value > bestValue) { bestValue = value; if (value > alpha) { bestMove = move; if (PvNode && !rootNode) // Update pv even in fail-high case update_pv(ss->pv, move, (ss+1)->pv); if (PvNode && value < beta) // Update alpha! Always alpha < beta alpha = value; else { assert(value >= beta); // Fail high ss->statScore = 0; break; } } } if (move != bestMove) { if (captureOrPromotion && captureCount < 32) capturesSearched[captureCount++] = move; else if (!captureOrPromotion && quietCount < 64) quietsSearched[quietCount++] = move; } } // The following condition would detect a stop only after move loop has been // completed. But in this case bestValue is valid because we have fully // searched our subtree, and we can anyhow save the result in TT. /* if (Threads.stop) return VALUE_DRAW; */ // Step 20. Check for mate and stalemate // All legal moves have been searched and if there are no legal moves, it // must be a mate or a stalemate. If we are in a singular extension search then // return a fail low score. assert(moveCount || !inCheck || excludedMove || !MoveList(pos).size()); if (!moveCount) bestValue = excludedMove ? alpha : inCheck ? pos.checkmate_value(ss->ply) : pos.stalemate_value(ss->ply); else if (bestMove) update_all_stats(pos, ss, bestMove, bestValue, beta, prevSq, quietsSearched, quietCount, capturesSearched, captureCount, depth); // Bonus for prior countermove that caused the fail low else if ( (depth >= 3 || PvNode) && !priorCapture) update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, stat_bonus(depth)); if (PvNode) bestValue = std::min(bestValue, maxValue); if (!excludedMove) tte->save(posKey, value_to_tt(bestValue, ss->ply), ttPv, bestValue >= beta ? BOUND_LOWER : PvNode && bestMove ? BOUND_EXACT : BOUND_UPPER, depth, bestMove, ss->staticEval); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); return bestValue; } // qsearch() is the quiescence search function, which is called by the main search // function with zero depth, or recursively with further decreasing depth per call. template Value qsearch(Position& pos, Stack* ss, Value alpha, Value beta, Depth depth) { constexpr bool PvNode = NT == PV; assert(alpha >= -VALUE_INFINITE && alpha < beta && beta <= VALUE_INFINITE); assert(PvNode || (alpha == beta - 1)); assert(depth <= 0); Move pv[MAX_PLY+1]; StateInfo st; TTEntry* tte; Key posKey; Move ttMove, move, bestMove; Depth ttDepth; Value bestValue, value, ttValue, futilityValue, futilityBase, oldAlpha; bool ttHit, pvHit, inCheck, givesCheck, captureOrPromotion, evasionPrunable; int moveCount; if (PvNode) { oldAlpha = alpha; // To flag BOUND_EXACT when eval above alpha and no available moves (ss+1)->pv = pv; ss->pv[0] = MOVE_NONE; } Thread* thisThread = pos.this_thread(); (ss+1)->ply = ss->ply + 1; bestMove = MOVE_NONE; inCheck = pos.checkers(); moveCount = 0; Value gameResult; if (pos.is_game_end(gameResult, ss->ply)) return gameResult; // Check for maximum ply reached if (ss->ply >= MAX_PLY) return !inCheck ? evaluate(pos) : VALUE_DRAW; assert(0 <= ss->ply && ss->ply < MAX_PLY); // Decide whether or not to include checks: this fixes also the type of // TT entry depth that we are going to use. Note that in qsearch we use // only two types of depth in TT: DEPTH_QS_CHECKS or DEPTH_QS_NO_CHECKS. ttDepth = inCheck || depth >= DEPTH_QS_CHECKS ? DEPTH_QS_CHECKS : DEPTH_QS_NO_CHECKS; // Transposition table lookup posKey = pos.key(); tte = TT.probe(posKey, ttHit); ttValue = ttHit ? value_from_tt(tte->value(), ss->ply, pos.rule50_count()) : VALUE_NONE; ttMove = ttHit ? tte->move() : MOVE_NONE; pvHit = ttHit && tte->is_pv(); if ( !PvNode && ttHit && tte->depth() >= ttDepth && ttValue != VALUE_NONE // Only in case of TT access race && (ttValue >= beta ? (tte->bound() & BOUND_LOWER) : (tte->bound() & BOUND_UPPER))) return ttValue; // Evaluate the position statically if (inCheck) { ss->staticEval = VALUE_NONE; bestValue = futilityBase = -VALUE_INFINITE; } else { if (ttHit) { // Never assume anything about values stored in TT if ((ss->staticEval = bestValue = tte->eval()) == VALUE_NONE) ss->staticEval = bestValue = evaluate(pos); // Can ttValue be used as a better position evaluation? if ( ttValue != VALUE_NONE && (tte->bound() & (ttValue > bestValue ? BOUND_LOWER : BOUND_UPPER))) bestValue = ttValue; } else ss->staticEval = bestValue = (ss-1)->currentMove != MOVE_NULL ? evaluate(pos) : -(ss-1)->staticEval + 2 * Eval::tempo_value(pos); // Stand pat. Return immediately if static value is at least beta if (bestValue >= beta) { if (!ttHit) tte->save(posKey, value_to_tt(bestValue, ss->ply), pvHit, BOUND_LOWER, DEPTH_NONE, MOVE_NONE, ss->staticEval); return bestValue; } if (PvNode && bestValue > alpha) alpha = bestValue; futilityBase = bestValue + 154; } const PieceToHistory* contHist[] = { (ss-1)->continuationHistory, (ss-2)->continuationHistory, nullptr , (ss-4)->continuationHistory, nullptr , (ss-6)->continuationHistory }; // Initialize a MovePicker object for the current position, and prepare // to search the moves. Because the depth is <= 0 here, only captures, // queen promotions and checks (only if depth >= DEPTH_QS_CHECKS) will // be generated. MovePicker mp(pos, ttMove, depth, &thisThread->mainHistory, &thisThread->captureHistory, contHist, to_sq((ss-1)->currentMove)); // Loop through the moves until no moves remain or a beta cutoff occurs while ((move = mp.next_move()) != MOVE_NONE) { assert(is_ok(move)); givesCheck = pos.gives_check(move); captureOrPromotion = pos.capture_or_promotion(move); moveCount++; // Avoid qsearch explosion for clobber if (type_of(pos.moved_piece(move)) == CLOBBER_PIECE && bestValue > VALUE_MATED_IN_MAX_PLY) continue; // Futility pruning if ( !inCheck && !givesCheck && !( pos.extinction_value() == -VALUE_MATE && pos.extinction_piece_types().find(ALL_PIECES) == pos.extinction_piece_types().end()) && futilityBase > -VALUE_KNOWN_WIN && !pos.advanced_pawn_push(move)) { assert(type_of(move) != ENPASSANT); // Due to !pos.advanced_pawn_push futilityValue = futilityBase + PieceValue[EG][pos.piece_on(to_sq(move))]; if (futilityValue <= alpha) { bestValue = std::max(bestValue, futilityValue); continue; } if (futilityBase <= alpha && !pos.see_ge(move, VALUE_ZERO + 1)) { bestValue = std::max(bestValue, futilityBase); continue; } } // Detect non-capture evasions that are candidates to be pruned evasionPrunable = inCheck && (depth != 0 || moveCount > 2) && bestValue > VALUE_MATED_IN_MAX_PLY && !pos.capture(move); // Don't search moves with negative SEE values if ( (!inCheck || evasionPrunable) && !pos.see_ge(move)) continue; // Speculative prefetch as early as possible prefetch(TT.first_entry(pos.key_after(move))); // Check for legality just before making the move if (!pos.legal(move)) { moveCount--; continue; } ss->currentMove = move; ss->continuationHistory = &thisThread->continuationHistory[inCheck] [captureOrPromotion] [history_slot(pos.moved_piece(move))] [to_sq(move)]; // Make and search the move pos.do_move(move, st, givesCheck); value = -qsearch(pos, ss+1, -beta, -alpha, depth - 1); pos.undo_move(move); assert(value > -VALUE_INFINITE && value < VALUE_INFINITE); // Check for a new best move if (value > bestValue) { bestValue = value; if (value > alpha) { bestMove = move; if (PvNode) // Update pv even in fail-high case update_pv(ss->pv, move, (ss+1)->pv); if (PvNode && value < beta) // Update alpha here! alpha = value; else break; // Fail high } } } // All legal moves have been searched. A special case: If we're in check // and no legal moves were found, it is checkmate. if (inCheck && bestValue == -VALUE_INFINITE) return pos.checkmate_value(ss->ply); // Plies to mate from the root tte->save(posKey, value_to_tt(bestValue, ss->ply), pvHit, bestValue >= beta ? BOUND_LOWER : PvNode && bestValue > oldAlpha ? BOUND_EXACT : BOUND_UPPER, ttDepth, bestMove, ss->staticEval); assert(bestValue > -VALUE_INFINITE && bestValue < VALUE_INFINITE); return bestValue; } // value_to_tt() adjusts a mate score from "plies to mate from the root" to // "plies to mate from the current position". Non-mate scores are unchanged. // The function is called before storing a value in the transposition table. Value value_to_tt(Value v, int ply) { assert(v != VALUE_NONE); return v >= VALUE_MATE_IN_MAX_PLY ? v + ply : v <= VALUE_MATED_IN_MAX_PLY ? v - ply : v; } // value_from_tt() is the inverse of value_to_tt(): It adjusts a mate score // from the transposition table (which refers to the plies to mate/be mated // from current position) to "plies to mate/be mated from the root". Value value_from_tt(Value v, int ply, int r50c) { return v == VALUE_NONE ? VALUE_NONE : v >= VALUE_MATE_IN_MAX_PLY ? VALUE_MATE - v > 99 - r50c ? VALUE_MATE_IN_MAX_PLY : v - ply : v <= VALUE_MATED_IN_MAX_PLY ? VALUE_MATE + v > 99 - r50c ? VALUE_MATED_IN_MAX_PLY : v + ply : v; } // update_pv() adds current move and appends child pv[] void update_pv(Move* pv, Move move, Move* childPv) { for (*pv++ = move; childPv && *childPv != MOVE_NONE; ) *pv++ = *childPv++; *pv = MOVE_NONE; } // update_all_stats() updates stats at the end of search() when a bestMove is found void update_all_stats(const Position& pos, Stack* ss, Move bestMove, Value bestValue, Value beta, Square prevSq, Move* quietsSearched, int quietCount, Move* capturesSearched, int captureCount, Depth depth) { int bonus1, bonus2; Color us = pos.side_to_move(); Thread* thisThread = pos.this_thread(); CapturePieceToHistory& captureHistory = thisThread->captureHistory; Piece moved_piece = pos.moved_piece(bestMove); PieceType captured = type_of(pos.piece_on(to_sq(bestMove))); bonus1 = stat_bonus(depth + 1); bonus2 = bestValue > beta + PawnValueMg ? bonus1 // larger bonus : stat_bonus(depth); // smaller bonus if (!pos.capture_or_promotion(bestMove)) { update_quiet_stats(pos, ss, bestMove, bonus2); // Decrease all the non-best quiet moves for (int i = 0; i < quietCount; ++i) { thisThread->mainHistory[us][from_to(quietsSearched[i])] << -bonus2; update_continuation_histories(ss, pos.moved_piece(quietsSearched[i]), to_sq(quietsSearched[i]), -bonus2); } } else captureHistory[moved_piece][to_sq(bestMove)][captured] << bonus1; // Extra penalty for a quiet TT or main killer move in previous ply when it gets refuted if ( ((ss-1)->moveCount == 1 || ((ss-1)->currentMove == (ss-1)->killers[0])) && !pos.captured_piece()) update_continuation_histories(ss-1, pos.piece_on(prevSq), prevSq, -bonus1); // Decrease all the non-best capture moves for (int i = 0; i < captureCount; ++i) { moved_piece = pos.moved_piece(capturesSearched[i]); captured = type_of(pos.piece_on(to_sq(capturesSearched[i]))); captureHistory[moved_piece][to_sq(capturesSearched[i])][captured] << -bonus1; } } // update_continuation_histories() updates histories of the move pairs formed // by moves at ply -1, -2, and -4 with current move. void update_continuation_histories(Stack* ss, Piece pc, Square to, int bonus) { for (int i : {1, 2, 4, 6}) if (is_ok((ss-i)->currentMove)) (*(ss-i)->continuationHistory)[history_slot(pc)][to] << bonus; } // update_quiet_stats() updates move sorting heuristics void update_quiet_stats(const Position& pos, Stack* ss, Move move, int bonus) { if (ss->killers[0] != move) { ss->killers[1] = ss->killers[0]; ss->killers[0] = move; } Color us = pos.side_to_move(); Thread* thisThread = pos.this_thread(); thisThread->mainHistory[us][from_to(move)] << bonus; update_continuation_histories(ss, pos.moved_piece(move), to_sq(move), bonus); if (type_of(pos.moved_piece(move)) != PAWN && type_of(move) != DROP) thisThread->mainHistory[us][from_to(reverse_move(move))] << -bonus; if (is_ok((ss-1)->currentMove)) { Square prevSq = to_sq((ss-1)->currentMove); thisThread->counterMoves[pos.piece_on(prevSq)][prevSq] = move; } } // When playing with strength handicap, choose best move among a set of RootMoves // using a statistical rule dependent on 'level'. Idea by Heinz van Saanen. Move Skill::pick_best(size_t multiPV) { const RootMoves& rootMoves = Threads.main()->rootMoves; static PRNG rng(now()); // PRNG sequence should be non-deterministic // RootMoves are already sorted by score in descending order Value topScore = rootMoves[0].score; int delta = std::min(topScore - rootMoves[multiPV - 1].score, PawnValueMg); int weakness = 120 - 2 * level; int maxScore = -VALUE_INFINITE; // Choose best move. For each move score we add two terms, both dependent on // weakness. One is deterministic and bigger for weaker levels, and one is // random. Then we choose the move with the resulting highest score. for (size_t i = 0; i < multiPV; ++i) { // This is our magic formula int push = ( weakness * int(topScore - rootMoves[i].score) + delta * (rng.rand() % weakness)) / 128; if (rootMoves[i].score + push >= maxScore) { maxScore = rootMoves[i].score + push; best = rootMoves[i].pv[0]; } } return best; } } // namespace /// MainThread::check_time() is used to print debug info and, more importantly, /// to detect when we are out of available time and thus stop the search. void MainThread::check_time() { if (--callsCnt > 0) return; // When using nodes, ensure checking rate is not lower than 0.1% of nodes callsCnt = Limits.nodes ? std::min(1024, int(Limits.nodes / 1024)) : 1024; static TimePoint lastInfoTime = now(); TimePoint elapsed = Time.elapsed(); TimePoint tick = Limits.startTime + elapsed; if (tick - lastInfoTime >= 1000) { lastInfoTime = tick; dbg_print(); } // We should not stop pondering until told so by the GUI if (ponder) return; if ( rootPos.two_boards() && Time.elapsed() < Limits.time[rootPos.side_to_move()] - 1000 && (Partner.sitRequested || Partner.weDead)) return; if ( (Limits.use_time_management() && (elapsed > Time.maximum() - 10 || stopOnPonderhit)) || (Limits.movetime && elapsed >= Limits.movetime) || (Limits.nodes && Threads.nodes_searched() >= (uint64_t)Limits.nodes)) Threads.stop = true; } /// UCI::pv() formats PV information according to the UCI protocol. UCI requires /// that all (if any) unsearched PV lines are sent using a previous search score. string UCI::pv(const Position& pos, Depth depth, Value alpha, Value beta) { std::stringstream ss; TimePoint elapsed = Time.elapsed() + 1; const RootMoves& rootMoves = pos.this_thread()->rootMoves; size_t pvIdx = pos.this_thread()->pvIdx; size_t multiPV = std::min((size_t)Options["MultiPV"], rootMoves.size()); uint64_t nodesSearched = Threads.nodes_searched(); uint64_t tbHits = Threads.tb_hits() + (TB::RootInTB ? rootMoves.size() : 0); for (size_t i = 0; i < multiPV; ++i) { bool updated = rootMoves[i].score != -VALUE_INFINITE; if (depth == 1 && !updated) continue; Depth d = updated ? depth : depth - 1; Value v = updated ? rootMoves[i].score : rootMoves[i].previousScore; bool tb = TB::RootInTB && abs(v) < VALUE_MATE - MAX_PLY; v = tb ? rootMoves[i].tbScore : v; if (ss.rdbuf()->in_avail()) // Not at first line ss << "\n"; if (Options["Protocol"] == "xboard") { ss << d << " " << UCI::value(v) << " " << elapsed / 10 << " " << nodesSearched << " " << rootMoves[i].selDepth << " " << nodesSearched * 1000 / elapsed << " " << tbHits << "\t"; for (Move m : rootMoves[i].pv) ss << " " << UCI::move(pos, m); } else { ss << "info" << " depth " << d << " seldepth " << rootMoves[i].selDepth << " multipv " << i + 1 << " score " << UCI::value(v); if (!tb && i == pvIdx) ss << (v >= beta ? " lowerbound" : v <= alpha ? " upperbound" : ""); ss << " nodes " << nodesSearched << " nps " << nodesSearched * 1000 / elapsed; if (elapsed > 1000) // Earlier makes little sense ss << " hashfull " << TT.hashfull(); ss << " tbhits " << tbHits << " time " << elapsed << " pv"; for (Move m : rootMoves[i].pv) ss << " " << UCI::move(pos, m); } } return ss.str(); } /// RootMove::extract_ponder_from_tt() is called in case we have no ponder move /// before exiting the search, for instance, in case we stop the search during a /// fail high at root. We try hard to have a ponder move to return to the GUI, /// otherwise in case of 'ponder on' we have nothing to think on. bool RootMove::extract_ponder_from_tt(Position& pos) { StateInfo st; bool ttHit; assert(pv.size() == 1); if (pv[0] == MOVE_NONE) return false; pos.do_move(pv[0], st); TTEntry* tte = TT.probe(pos.key(), ttHit); if (ttHit) { Move m = tte->move(); // Local copy to be SMP safe if (MoveList(pos).contains(m)) pv.push_back(m); } pos.undo_move(pv[0]); return pv.size() > 1; } void Tablebases::rank_root_moves(Position& pos, Search::RootMoves& rootMoves) { RootInTB = false; UseRule50 = bool(Options["Syzygy50MoveRule"]); ProbeDepth = int(Options["SyzygyProbeDepth"]); Cardinality = int(Options["SyzygyProbeLimit"]); bool dtz_available = true; // Tables with fewer pieces than SyzygyProbeLimit are searched with // ProbeDepth == DEPTH_ZERO if (Cardinality > MaxCardinality) { Cardinality = MaxCardinality; ProbeDepth = 0; } if (Cardinality >= popcount(pos.pieces()) && !pos.can_castle(ANY_CASTLING)) { // Rank moves using DTZ tables RootInTB = root_probe(pos, rootMoves); if (!RootInTB) { // DTZ tables are missing; try to rank moves using WDL tables dtz_available = false; RootInTB = root_probe_wdl(pos, rootMoves); } } if (RootInTB) { // Sort moves according to TB rank std::sort(rootMoves.begin(), rootMoves.end(), [](const RootMove &a, const RootMove &b) { return a.tbRank > b.tbRank; } ); // Probe during search only if DTZ is not available and we are winning if (dtz_available || rootMoves[0].tbScore <= VALUE_DRAW) Cardinality = 0; } else { // Clean up if root_probe() and root_probe_wdl() have failed for (auto& m : rootMoves) m.tbRank = 0; } } Fairy-Stockfish-fairy_sf_11_1/src/search.h000066400000000000000000000062651366242550200206270ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef SEARCH_H_INCLUDED #define SEARCH_H_INCLUDED #include #include "misc.h" #include "movepick.h" #include "types.h" class Position; namespace Search { /// Threshold used for countermoves based pruning constexpr int CounterMovePruneThreshold = 0; /// Stack struct keeps track of the information we need to remember from nodes /// shallower and deeper in the tree during the search. Each search thread has /// its own array of Stack objects, indexed by the current ply. struct Stack { Move* pv; PieceToHistory* continuationHistory; int ply; Move currentMove; Move excludedMove; Move killers[2]; Value staticEval; int statScore; int moveCount; }; /// RootMove struct is used for moves at the root of the tree. For each root move /// we store a score and a PV (really a refutation in the case of moves which /// fail low). Score is normally set at -VALUE_INFINITE for all non-pv moves. struct RootMove { explicit RootMove(Move m) : pv(1, m) {} bool extract_ponder_from_tt(Position& pos); bool operator==(const Move& m) const { return pv[0] == m; } bool operator<(const RootMove& m) const { // Sort in descending order return m.score != score ? m.score < score : m.previousScore < previousScore; } Value score = -VALUE_INFINITE; Value previousScore = -VALUE_INFINITE; int selDepth = 0; int tbRank = 0; int bestMoveCount = 0; Value tbScore; std::vector pv; }; typedef std::vector RootMoves; /// LimitsType struct stores information sent by GUI about available time to /// search the current move, maximum depth/time, or if we are in analysis mode. struct LimitsType { LimitsType() { // Init explicitly due to broken value-initialization of non POD in MSVC time[WHITE] = time[BLACK] = inc[WHITE] = inc[BLACK] = npmsec = movetime = TimePoint(0); movestogo = depth = mate = perft = infinite = 0; nodes = 0; } bool use_time_management() const { return !(mate | movetime | depth | nodes | perft | infinite); } std::vector searchmoves, banmoves; TimePoint time[COLOR_NB], inc[COLOR_NB], npmsec, movetime, startTime; int movestogo, depth, mate, perft, infinite; int64_t nodes; }; extern LimitsType Limits; void init(); void clear(); } // namespace Search #endif // #ifndef SEARCH_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/syzygy/000077500000000000000000000000001366242550200205565ustar00rootroot00000000000000Fairy-Stockfish-fairy_sf_11_1/src/syzygy/tbprobe.cpp000066400000000000000000001675731366242550200227420ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (c) 2013 Ronald de Man Copyright (C) 2016-2020 Marco Costalba, Lucas Braesch Stockfish 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. Stockfish 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 . */ #include #include #include #include // For std::memset and std::memcpy #include #include #include #include #include #include #include #include "../bitboard.h" #include "../movegen.h" #include "../position.h" #include "../search.h" #include "../types.h" #include "../uci.h" #include "tbprobe.h" #ifndef _WIN32 #include #include #include #include #else #define WIN32_LEAN_AND_MEAN #ifndef NOMINMAX # define NOMINMAX // Disable macros min() and max() #endif #include #endif using namespace Tablebases; int Tablebases::MaxCardinality; namespace { constexpr int TBPIECES = 7; // Max number of supported pieces enum { BigEndian, LittleEndian }; enum TBType { KEY, WDL, DTZ }; // Used as template parameter // Each table has a set of flags: all of them refer to DTZ tables, the last one to WDL tables enum TBFlag { STM = 1, Mapped = 2, WinPlies = 4, LossPlies = 8, Wide = 16, SingleValue = 128 }; inline WDLScore operator-(WDLScore d) { return WDLScore(-int(d)); } inline Square operator^=(Square& s, int i) { return s = Square(int(s) ^ i); } inline Square operator^(Square s, int i) { return Square(int(s) ^ i); } const std::string PieceToChar( " PNBRQ" + std::string(KING - QUEEN - 1, ' ') + "K" + std::string(PIECE_TYPE_NB - KING - 1, ' ') + " pnbrq" + std::string(KING - QUEEN - 1, ' ') + "k" + std::string(PIECE_TYPE_NB - KING - 1, ' ')); int MapPawns[SQUARE_NB]; int MapB1H1H7[SQUARE_NB]; int MapA1D1D4[SQUARE_NB]; int MapKK[10][SQUARE_NB]; // [MapA1D1D4][SQUARE_NB] int Binomial[6][SQUARE_NB]; // [k][n] k elements from a set of n elements int LeadPawnIdx[6][SQUARE_NB]; // [leadPawnsCnt][SQUARE_NB] int LeadPawnsSize[6][4]; // [leadPawnsCnt][FILE_A..FILE_D] // Comparison function to sort leading pawns in ascending MapPawns[] order bool pawns_comp(Square i, Square j) { return MapPawns[i] < MapPawns[j]; } int off_A1H8(Square sq) { return int(rank_of(sq)) - file_of(sq); } constexpr Value WDL_to_value[] = { -VALUE_MATE + MAX_PLY + 1, VALUE_DRAW - 2, VALUE_DRAW, VALUE_DRAW + 2, VALUE_MATE - MAX_PLY - 1 }; template inline void swap_endian(T& x) { static_assert(std::is_unsigned::value, "Argument of swap_endian not unsigned"); uint8_t tmp, *c = (uint8_t*)&x; for (int i = 0; i < Half; ++i) tmp = c[i], c[i] = c[End - i], c[End - i] = tmp; } template<> inline void swap_endian(uint8_t&) {} template T number(void* addr) { static const union { uint32_t i; char c[4]; } Le = { 0x01020304 }; static const bool IsLittleEndian = (Le.c[0] == 4); T v; if ((uintptr_t)addr & (alignof(T) - 1)) // Unaligned pointer (very rare) std::memcpy(&v, addr, sizeof(T)); else v = *((T*)addr); if (LE != IsLittleEndian) swap_endian(v); return v; } // DTZ tables don't store valid scores for moves that reset the rule50 counter // like captures and pawn moves but we can easily recover the correct dtz of the // previous move if we know the position's WDL score. int dtz_before_zeroing(WDLScore wdl) { return wdl == WDLWin ? 1 : wdl == WDLCursedWin ? 101 : wdl == WDLBlessedLoss ? -101 : wdl == WDLLoss ? -1 : 0; } // Return the sign of a number (-1, 0, 1) template int sign_of(T val) { return (T(0) < val) - (val < T(0)); } // Numbers in little endian used by sparseIndex[] to point into blockLength[] struct SparseEntry { char block[4]; // Number of block char offset[2]; // Offset within the block }; static_assert(sizeof(SparseEntry) == 6, "SparseEntry must be 6 bytes"); typedef uint16_t Sym; // Huffman symbol struct LR { enum Side { Left, Right }; uint8_t lr[3]; // The first 12 bits is the left-hand symbol, the second 12 // bits is the right-hand symbol. If symbol has length 1, // then the left-hand symbol is the stored value. template Sym get() { return S == Left ? ((lr[1] & 0xF) << 8) | lr[0] : S == Right ? (lr[2] << 4) | (lr[1] >> 4) : (assert(false), Sym(-1)); } }; static_assert(sizeof(LR) == 3, "LR tree entry must be 3 bytes"); // Tablebases data layout is structured as following: // // TBFile: memory maps/unmaps the physical .rtbw and .rtbz files // TBTable: one object for each file with corresponding indexing information // TBTables: has ownership of TBTable objects, keeping a list and a hash // class TBFile memory maps/unmaps the single .rtbw and .rtbz files. Files are // memory mapped for best performance. Files are mapped at first access: at init // time only existence of the file is checked. class TBFile : public std::ifstream { std::string fname; public: // Look for and open the file among the Paths directories where the .rtbw // and .rtbz files can be found. Multiple directories are separated by ";" // on Windows and by ":" on Unix-based operating systems. // // Example: // C:\tb\wdl345;C:\tb\wdl6;D:\tb\dtz345;D:\tb\dtz6 static std::string Paths; TBFile(const std::string& f) { #ifndef _WIN32 constexpr char SepChar = ':'; #else constexpr char SepChar = ';'; #endif std::stringstream ss(Paths); std::string path; while (std::getline(ss, path, SepChar)) { fname = path + "/" + f; std::ifstream::open(fname); if (is_open()) return; } } // Memory map the file and check it. File should be already open and will be // closed after mapping. uint8_t* map(void** baseAddress, uint64_t* mapping, TBType type) { assert(is_open()); close(); // Need to re-open to get native file descriptor #ifndef _WIN32 struct stat statbuf; int fd = ::open(fname.c_str(), O_RDONLY); if (fd == -1) return *baseAddress = nullptr, nullptr; fstat(fd, &statbuf); if (statbuf.st_size % 64 != 16) { std::cerr << "Corrupt tablebase file " << fname << std::endl; exit(EXIT_FAILURE); } *mapping = statbuf.st_size; *baseAddress = mmap(nullptr, statbuf.st_size, PROT_READ, MAP_SHARED, fd, 0); madvise(*baseAddress, statbuf.st_size, MADV_RANDOM); ::close(fd); if (*baseAddress == MAP_FAILED) { std::cerr << "Could not mmap() " << fname << std::endl; exit(EXIT_FAILURE); } #else // Note FILE_FLAG_RANDOM_ACCESS is only a hint to Windows and as such may get ignored. HANDLE fd = CreateFile(fname.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING, FILE_FLAG_RANDOM_ACCESS, nullptr); if (fd == INVALID_HANDLE_VALUE) return *baseAddress = nullptr, nullptr; DWORD size_high; DWORD size_low = GetFileSize(fd, &size_high); if (size_low % 64 != 16) { std::cerr << "Corrupt tablebase file " << fname << std::endl; exit(EXIT_FAILURE); } HANDLE mmap = CreateFileMapping(fd, nullptr, PAGE_READONLY, size_high, size_low, nullptr); CloseHandle(fd); if (!mmap) { std::cerr << "CreateFileMapping() failed" << std::endl; exit(EXIT_FAILURE); } *mapping = (uint64_t)mmap; *baseAddress = MapViewOfFile(mmap, FILE_MAP_READ, 0, 0, 0); if (!*baseAddress) { std::cerr << "MapViewOfFile() failed, name = " << fname << ", error = " << GetLastError() << std::endl; exit(EXIT_FAILURE); } #endif uint8_t* data = (uint8_t*)*baseAddress; constexpr uint8_t Magics[][4] = { { 0xD7, 0x66, 0x0C, 0xA5 }, { 0x71, 0xE8, 0x23, 0x5D } }; if (memcmp(data, Magics[type == WDL], 4)) { std::cerr << "Corrupted table in file " << fname << std::endl; unmap(*baseAddress, *mapping); return *baseAddress = nullptr, nullptr; } return data + 4; // Skip Magics's header } static void unmap(void* baseAddress, uint64_t mapping) { #ifndef _WIN32 munmap(baseAddress, mapping); #else UnmapViewOfFile(baseAddress); CloseHandle((HANDLE)mapping); #endif } }; std::string TBFile::Paths; // struct PairsData contains low level indexing information to access TB data. // There are 8, 4 or 2 PairsData records for each TBTable, according to type of // table and if positions have pawns or not. It is populated at first access. struct PairsData { uint8_t flags; // Table flags, see enum TBFlag uint8_t maxSymLen; // Maximum length in bits of the Huffman symbols uint8_t minSymLen; // Minimum length in bits of the Huffman symbols uint32_t blocksNum; // Number of blocks in the TB file size_t sizeofBlock; // Block size in bytes size_t span; // About every span values there is a SparseIndex[] entry Sym* lowestSym; // lowestSym[l] is the symbol of length l with the lowest value LR* btree; // btree[sym] stores the left and right symbols that expand sym uint16_t* blockLength; // Number of stored positions (minus one) for each block: 1..65536 uint32_t blockLengthSize; // Size of blockLength[] table: padded so it's bigger than blocksNum SparseEntry* sparseIndex; // Partial indices into blockLength[] size_t sparseIndexSize; // Size of SparseIndex[] table uint8_t* data; // Start of Huffman compressed data std::vector base64; // base64[l - min_sym_len] is the 64bit-padded lowest symbol of length l std::vector symlen; // Number of values (-1) represented by a given Huffman symbol: 1..256 Piece pieces[TBPIECES]; // Position pieces: the order of pieces defines the groups uint64_t groupIdx[TBPIECES+1]; // Start index used for the encoding of the group's pieces int groupLen[TBPIECES+1]; // Number of pieces in a given group: KRKN -> (3, 1) uint16_t map_idx[4]; // WDLWin, WDLLoss, WDLCursedWin, WDLBlessedLoss (used in DTZ) }; // struct TBTable contains indexing information to access the corresponding TBFile. // There are 2 types of TBTable, corresponding to a WDL or a DTZ file. TBTable // is populated at init time but the nested PairsData records are populated at // first access, when the corresponding file is memory mapped. template struct TBTable { typedef typename std::conditional::type Ret; static constexpr int Sides = Type == WDL ? 2 : 1; std::atomic_bool ready; void* baseAddress; uint8_t* map; uint64_t mapping; Key key; Key key2; int pieceCount; bool hasPawns; bool hasUniquePieces; uint8_t pawnCount[2]; // [Lead color / other color] PairsData items[Sides][4]; // [wtm / btm][FILE_A..FILE_D or 0] PairsData* get(int stm, int f) { return &items[stm % Sides][hasPawns ? f : 0]; } TBTable() : ready(false), baseAddress(nullptr) {} explicit TBTable(const std::string& code); explicit TBTable(const TBTable& wdl); ~TBTable() { if (baseAddress) TBFile::unmap(baseAddress, mapping); } }; template<> TBTable::TBTable(const std::string& code) : TBTable() { StateInfo st; Position pos; key = pos.set(code, WHITE, &st).material_key(); pieceCount = pos.count(); hasPawns = pos.pieces(PAWN); hasUniquePieces = false; for (Color c : { WHITE, BLACK }) for (PieceType pt = PAWN; pt < KING; ++pt) if (popcount(pos.pieces(c, pt)) == 1) hasUniquePieces = true; // Set the leading color. In case both sides have pawns the leading color // is the side with less pawns because this leads to better compression. bool c = !pos.count(BLACK) || ( pos.count(WHITE) && pos.count(BLACK) >= pos.count(WHITE)); pawnCount[0] = pos.count(c ? WHITE : BLACK); pawnCount[1] = pos.count(c ? BLACK : WHITE); key2 = pos.set(code, BLACK, &st).material_key(); } template<> TBTable::TBTable(const TBTable& wdl) : TBTable() { // Use the corresponding WDL table to avoid recalculating all from scratch key = wdl.key; key2 = wdl.key2; pieceCount = wdl.pieceCount; hasPawns = wdl.hasPawns; hasUniquePieces = wdl.hasUniquePieces; pawnCount[0] = wdl.pawnCount[0]; pawnCount[1] = wdl.pawnCount[1]; } // class TBTables creates and keeps ownership of the TBTable objects, one for // each TB file found. It supports a fast, hash based, table lookup. Populated // at init time, accessed at probe time. class TBTables { typedef std::tuple*, TBTable*> Entry; static constexpr int Size = 1 << 12; // 4K table, indexed by key's 12 lsb static constexpr int Overflow = 1; // Number of elements allowed to map to the last bucket Entry hashTable[Size + Overflow]; std::deque> wdlTable; std::deque> dtzTable; void insert(Key key, TBTable* wdl, TBTable* dtz) { uint32_t homeBucket = (uint32_t)key & (Size - 1); Entry entry = std::make_tuple(key, wdl, dtz); // Ensure last element is empty to avoid overflow when looking up for (uint32_t bucket = homeBucket; bucket < Size + Overflow - 1; ++bucket) { Key otherKey = std::get(hashTable[bucket]); if (otherKey == key || !std::get(hashTable[bucket])) { hashTable[bucket] = entry; return; } // Robin Hood hashing: If we've probed for longer than this element, // insert here and search for a new spot for the other element instead. uint32_t otherHomeBucket = (uint32_t)otherKey & (Size - 1); if (otherHomeBucket > homeBucket) { swap(entry, hashTable[bucket]); key = otherKey; homeBucket = otherHomeBucket; } } std::cerr << "TB hash table size too low!" << std::endl; exit(EXIT_FAILURE); } public: template TBTable* get(Key key) { for (const Entry* entry = &hashTable[(uint32_t)key & (Size - 1)]; ; ++entry) { if (std::get(*entry) == key || !std::get(*entry)) return std::get(*entry); } } void clear() { memset(hashTable, 0, sizeof(hashTable)); wdlTable.clear(); dtzTable.clear(); } size_t size() const { return wdlTable.size(); } void add(const std::vector& pieces); }; TBTables TBTables; // If the corresponding file exists two new objects TBTable and TBTable // are created and added to the lists and hash table. Called at init time. void TBTables::add(const std::vector& pieces) { std::string code; for (PieceType pt : pieces) code += PieceToChar[pt]; TBFile file(code.insert(code.find('K', 1), "v") + ".rtbw"); // KRK -> KRvK if (!file.is_open()) // Only WDL file is checked return; file.close(); MaxCardinality = std::max((int)pieces.size(), MaxCardinality); wdlTable.emplace_back(code); dtzTable.emplace_back(wdlTable.back()); // Insert into the hash keys for both colors: KRvK with KR white and black insert(wdlTable.back().key , &wdlTable.back(), &dtzTable.back()); insert(wdlTable.back().key2, &wdlTable.back(), &dtzTable.back()); } // TB tables are compressed with canonical Huffman code. The compressed data is divided into // blocks of size d->sizeofBlock, and each block stores a variable number of symbols. // Each symbol represents either a WDL or a (remapped) DTZ value, or a pair of other symbols // (recursively). If you keep expanding the symbols in a block, you end up with up to 65536 // WDL or DTZ values. Each symbol represents up to 256 values and will correspond after // Huffman coding to at least 1 bit. So a block of 32 bytes corresponds to at most // 32 x 8 x 256 = 65536 values. This maximum is only reached for tables that consist mostly // of draws or mostly of wins, but such tables are actually quite common. In principle, the // blocks in WDL tables are 64 bytes long (and will be aligned on cache lines). But for // mostly-draw or mostly-win tables this can leave many 64-byte blocks only half-filled, so // in such cases blocks are 32 bytes long. The blocks of DTZ tables are up to 1024 bytes long. // The generator picks the size that leads to the smallest table. The "book" of symbols and // Huffman codes is the same for all blocks in the table. A non-symmetric pawnless TB file // will have one table for wtm and one for btm, a TB file with pawns will have tables per // file a,b,c,d also in this case one set for wtm and one for btm. int decompress_pairs(PairsData* d, uint64_t idx) { // Special case where all table positions store the same value if (d->flags & TBFlag::SingleValue) return d->minSymLen; // First we need to locate the right block that stores the value at index "idx". // Because each block n stores blockLength[n] + 1 values, the index i of the block // that contains the value at position idx is: // // for (i = -1, sum = 0; sum <= idx; i++) // sum += blockLength[i + 1] + 1; // // This can be slow, so we use SparseIndex[] populated with a set of SparseEntry that // point to known indices into blockLength[]. Namely SparseIndex[k] is a SparseEntry // that stores the blockLength[] index and the offset within that block of the value // with index I(k), where: // // I(k) = k * d->span + d->span / 2 (1) // First step is to get the 'k' of the I(k) nearest to our idx, using definition (1) uint32_t k = idx / d->span; // Then we read the corresponding SparseIndex[] entry uint32_t block = number(&d->sparseIndex[k].block); int offset = number(&d->sparseIndex[k].offset); // Now compute the difference idx - I(k). From definition of k we know that // // idx = k * d->span + idx % d->span (2) // // So from (1) and (2) we can compute idx - I(K): int diff = idx % d->span - d->span / 2; // Sum the above to offset to find the offset corresponding to our idx offset += diff; // Move to previous/next block, until we reach the correct block that contains idx, // that is when 0 <= offset <= d->blockLength[block] while (offset < 0) offset += d->blockLength[--block] + 1; while (offset > d->blockLength[block]) offset -= d->blockLength[block++] + 1; // Finally, we find the start address of our block of canonical Huffman symbols uint32_t* ptr = (uint32_t*)(d->data + ((uint64_t)block * d->sizeofBlock)); // Read the first 64 bits in our block, this is a (truncated) sequence of // unknown number of symbols of unknown length but we know the first one // is at the beginning of this 64 bits sequence. uint64_t buf64 = number(ptr); ptr += 2; int buf64Size = 64; Sym sym; while (true) { int len = 0; // This is the symbol length - d->min_sym_len // Now get the symbol length. For any symbol s64 of length l right-padded // to 64 bits we know that d->base64[l-1] >= s64 >= d->base64[l] so we // can find the symbol length iterating through base64[]. while (buf64 < d->base64[len]) ++len; // All the symbols of a given length are consecutive integers (numerical // sequence property), so we can compute the offset of our symbol of // length len, stored at the beginning of buf64. sym = (buf64 - d->base64[len]) >> (64 - len - d->minSymLen); // Now add the value of the lowest symbol of length len to get our symbol sym += number(&d->lowestSym[len]); // If our offset is within the number of values represented by symbol sym // we are done... if (offset < d->symlen[sym] + 1) break; // ...otherwise update the offset and continue to iterate offset -= d->symlen[sym] + 1; len += d->minSymLen; // Get the real length buf64 <<= len; // Consume the just processed symbol buf64Size -= len; if (buf64Size <= 32) { // Refill the buffer buf64Size += 32; buf64 |= (uint64_t)number(ptr++) << (64 - buf64Size); } } // Ok, now we have our symbol that expands into d->symlen[sym] + 1 symbols. // We binary-search for our value recursively expanding into the left and // right child symbols until we reach a leaf node where symlen[sym] + 1 == 1 // that will store the value we need. while (d->symlen[sym]) { Sym left = d->btree[sym].get(); // If a symbol contains 36 sub-symbols (d->symlen[sym] + 1 = 36) and // expands in a pair (d->symlen[left] = 23, d->symlen[right] = 11), then // we know that, for instance the ten-th value (offset = 10) will be on // the left side because in Recursive Pairing child symbols are adjacent. if (offset < d->symlen[left] + 1) sym = left; else { offset -= d->symlen[left] + 1; sym = d->btree[sym].get(); } } return d->btree[sym].get(); } bool check_dtz_stm(TBTable*, int, File) { return true; } bool check_dtz_stm(TBTable* entry, int stm, File f) { auto flags = entry->get(stm, f)->flags; return (flags & TBFlag::STM) == stm || ((entry->key == entry->key2) && !entry->hasPawns); } // DTZ scores are sorted by frequency of occurrence and then assigned the // values 0, 1, 2, ... in order of decreasing frequency. This is done for each // of the four WDLScore values. The mapping information necessary to reconstruct // the original values is stored in the TB file and read during map[] init. WDLScore map_score(TBTable*, File, int value, WDLScore) { return WDLScore(value - 2); } int map_score(TBTable* entry, File f, int value, WDLScore wdl) { constexpr int WDLMap[] = { 1, 3, 0, 2, 0 }; auto flags = entry->get(0, f)->flags; uint8_t* map = entry->map; uint16_t* idx = entry->get(0, f)->map_idx; if (flags & TBFlag::Mapped) { if (flags & TBFlag::Wide) value = ((uint16_t *)map)[idx[WDLMap[wdl + 2]] + value]; else value = map[idx[WDLMap[wdl + 2]] + value]; } // DTZ tables store distance to zero in number of moves or plies. We // want to return plies, so we have convert to plies when needed. if ( (wdl == WDLWin && !(flags & TBFlag::WinPlies)) || (wdl == WDLLoss && !(flags & TBFlag::LossPlies)) || wdl == WDLCursedWin || wdl == WDLBlessedLoss) value *= 2; return value + 1; } // Compute a unique index out of a position and use it to probe the TB file. To // encode k pieces of same type and color, first sort the pieces by square in // ascending order s1 <= s2 <= ... <= sk then compute the unique index as: // // idx = Binomial[1][s1] + Binomial[2][s2] + ... + Binomial[k][sk] // template Ret do_probe_table(const Position& pos, T* entry, WDLScore wdl, ProbeState* result) { Square squares[TBPIECES]; Piece pieces[TBPIECES]; uint64_t idx; int next = 0, size = 0, leadPawnsCnt = 0; PairsData* d; Bitboard b, leadPawns = 0; File tbFile = FILE_A; // A given TB entry like KRK has associated two material keys: KRvk and Kvkr. // If both sides have the same pieces keys are equal. In this case TB tables // only store the 'white to move' case, so if the position to lookup has black // to move, we need to switch the color and flip the squares before to lookup. bool symmetricBlackToMove = (entry->key == entry->key2 && pos.side_to_move()); // TB files are calculated for white as stronger side. For instance we have // KRvK, not KvKR. A position where stronger side is white will have its // material key == entry->key, otherwise we have to switch the color and // flip the squares before to lookup. bool blackStronger = (pos.material_key() != entry->key); int flipColor = (symmetricBlackToMove || blackStronger) * PIECE_TYPE_NB; int flipSquares = (symmetricBlackToMove || blackStronger) * 56; int stm = (symmetricBlackToMove || blackStronger) ^ pos.side_to_move(); // For pawns, TB files store 4 separate tables according if leading pawn is on // file a, b, c or d after reordering. The leading pawn is the one with maximum // MapPawns[] value, that is the one most toward the edges and with lowest rank. if (entry->hasPawns) { // In all the 4 tables, pawns are at the beginning of the piece sequence and // their color is the reference one. So we just pick the first one. Piece pc = Piece(entry->get(0, 0)->pieces[0] ^ flipColor); assert(type_of(pc) == PAWN); leadPawns = b = pos.pieces(color_of(pc), PAWN); do squares[size++] = pop_lsb(&b) ^ flipSquares; while (b); leadPawnsCnt = size; std::swap(squares[0], *std::max_element(squares, squares + leadPawnsCnt, pawns_comp)); tbFile = map_to_queenside(file_of(squares[0])); } // DTZ tables are one-sided, i.e. they store positions only for white to // move or only for black to move, so check for side to move to be stm, // early exit otherwise. if (!check_dtz_stm(entry, stm, tbFile)) return *result = CHANGE_STM, Ret(); // Now we are ready to get all the position pieces (but the lead pawns) and // directly map them to the correct color and square. b = pos.pieces() ^ leadPawns; do { Square s = pop_lsb(&b); squares[size] = s ^ flipSquares; pieces[size++] = Piece(pos.piece_on(s) ^ flipColor); } while (b); assert(size >= 2); d = entry->get(stm, tbFile); // Then we reorder the pieces to have the same sequence as the one stored // in pieces[i]: the sequence that ensures the best compression. for (int i = leadPawnsCnt; i < size - 1; ++i) for (int j = i + 1; j < size; ++j) if (d->pieces[i] == pieces[j]) { std::swap(pieces[i], pieces[j]); std::swap(squares[i], squares[j]); break; } // Now we map again the squares so that the square of the lead piece is in // the triangle A1-D1-D4. if (file_of(squares[0]) > FILE_D) for (int i = 0; i < size; ++i) squares[i] ^= 7; // Horizontal flip: SQ_H1 -> SQ_A1 // Encode leading pawns starting with the one with minimum MapPawns[] and // proceeding in ascending order. if (entry->hasPawns) { idx = LeadPawnIdx[leadPawnsCnt][squares[0]]; std::sort(squares + 1, squares + leadPawnsCnt, pawns_comp); for (int i = 1; i < leadPawnsCnt; ++i) idx += Binomial[i][MapPawns[squares[i]]]; goto encode_remaining; // With pawns we have finished special treatments } // In positions withouth pawns, we further flip the squares to ensure leading // piece is below RANK_5. if (rank_of(squares[0]) > RANK_4) for (int i = 0; i < size; ++i) squares[i] ^= SQ_A8; // Vertical flip: SQ_A8 -> SQ_A1 // Look for the first piece of the leading group not on the A1-D4 diagonal // and ensure it is mapped below the diagonal. for (int i = 0; i < d->groupLen[0]; ++i) { if (!off_A1H8(squares[i])) continue; if (off_A1H8(squares[i]) > 0) // A1-H8 diagonal flip: SQ_A3 -> SQ_C3 for (int j = i; j < size; ++j) squares[j] = Square(((squares[j] >> 3) | (squares[j] << 3)) & 63); break; } // Encode the leading group. // // Suppose we have KRvK. Let's say the pieces are on square numbers wK, wR // and bK (each 0...63). The simplest way to map this position to an index // is like this: // // index = wK * 64 * 64 + wR * 64 + bK; // // But this way the TB is going to have 64*64*64 = 262144 positions, with // lots of positions being equivalent (because they are mirrors of each // other) and lots of positions being invalid (two pieces on one square, // adjacent kings, etc.). // Usually the first step is to take the wK and bK together. There are just // 462 ways legal and not-mirrored ways to place the wK and bK on the board. // Once we have placed the wK and bK, there are 62 squares left for the wR // Mapping its square from 0..63 to available squares 0..61 can be done like: // // wR -= (wR > wK) + (wR > bK); // // In words: if wR "comes later" than wK, we deduct 1, and the same if wR // "comes later" than bK. In case of two same pieces like KRRvK we want to // place the two Rs "together". If we have 62 squares left, we can place two // Rs "together" in 62 * 61 / 2 ways (we divide by 2 because rooks can be // swapped and still get the same position.) // // In case we have at least 3 unique pieces (inlcuded kings) we encode them // together. if (entry->hasUniquePieces) { int adjust1 = squares[1] > squares[0]; int adjust2 = (squares[2] > squares[0]) + (squares[2] > squares[1]); // First piece is below a1-h8 diagonal. MapA1D1D4[] maps the b1-d1-d3 // triangle to 0...5. There are 63 squares for second piece and and 62 // (mapped to 0...61) for the third. if (off_A1H8(squares[0])) idx = ( MapA1D1D4[squares[0]] * 63 + (squares[1] - adjust1)) * 62 + squares[2] - adjust2; // First piece is on a1-h8 diagonal, second below: map this occurence to // 6 to differentiate from the above case, rank_of() maps a1-d4 diagonal // to 0...3 and finally MapB1H1H7[] maps the b1-h1-h7 triangle to 0..27. else if (off_A1H8(squares[1])) idx = ( 6 * 63 + rank_of(squares[0]) * 28 + MapB1H1H7[squares[1]]) * 62 + squares[2] - adjust2; // First two pieces are on a1-h8 diagonal, third below else if (off_A1H8(squares[2])) idx = 6 * 63 * 62 + 4 * 28 * 62 + rank_of(squares[0]) * 7 * 28 + (rank_of(squares[1]) - adjust1) * 28 + MapB1H1H7[squares[2]]; // All 3 pieces on the diagonal a1-h8 else idx = 6 * 63 * 62 + 4 * 28 * 62 + 4 * 7 * 28 + rank_of(squares[0]) * 7 * 6 + (rank_of(squares[1]) - adjust1) * 6 + (rank_of(squares[2]) - adjust2); } else // We don't have at least 3 unique pieces, like in KRRvKBB, just map // the kings. idx = MapKK[MapA1D1D4[squares[0]]][squares[1]]; encode_remaining: idx *= d->groupIdx[0]; Square* groupSq = squares + d->groupLen[0]; // Encode remainig pawns then pieces according to square, in ascending order bool remainingPawns = entry->hasPawns && entry->pawnCount[1]; while (d->groupLen[++next]) { std::sort(groupSq, groupSq + d->groupLen[next]); uint64_t n = 0; // Map down a square if "comes later" than a square in the previous // groups (similar to what done earlier for leading group pieces). for (int i = 0; i < d->groupLen[next]; ++i) { auto f = [&](Square s) { return groupSq[i] > s; }; auto adjust = std::count_if(squares, groupSq, f); n += Binomial[i + 1][groupSq[i] - adjust - 8 * remainingPawns]; } remainingPawns = false; idx += n * d->groupIdx[next]; groupSq += d->groupLen[next]; } // Now that we have the index, decompress the pair and get the score return map_score(entry, tbFile, decompress_pairs(d, idx), wdl); } // Group together pieces that will be encoded together. The general rule is that // a group contains pieces of same type and color. The exception is the leading // group that, in case of positions withouth pawns, can be formed by 3 different // pieces (default) or by the king pair when there is not a unique piece apart // from the kings. When there are pawns, pawns are always first in pieces[]. // // As example KRKN -> KRK + N, KNNK -> KK + NN, KPPKP -> P + PP + K + K // // The actual grouping depends on the TB generator and can be inferred from the // sequence of pieces in piece[] array. template void set_groups(T& e, PairsData* d, int order[], File f) { int n = 0, firstLen = e.hasPawns ? 0 : e.hasUniquePieces ? 3 : 2; d->groupLen[n] = 1; // Number of pieces per group is stored in groupLen[], for instance in KRKN // the encoder will default on '111', so groupLen[] will be (3, 1). for (int i = 1; i < e.pieceCount; ++i) if (--firstLen > 0 || d->pieces[i] == d->pieces[i - 1]) d->groupLen[n]++; else d->groupLen[++n] = 1; d->groupLen[++n] = 0; // Zero-terminated // The sequence in pieces[] defines the groups, but not the order in which // they are encoded. If the pieces in a group g can be combined on the board // in N(g) different ways, then the position encoding will be of the form: // // g1 * N(g2) * N(g3) + g2 * N(g3) + g3 // // This ensures unique encoding for the whole position. The order of the // groups is a per-table parameter and could not follow the canonical leading // pawns/pieces -> remainig pawns -> remaining pieces. In particular the // first group is at order[0] position and the remaining pawns, when present, // are at order[1] position. bool pp = e.hasPawns && e.pawnCount[1]; // Pawns on both sides int next = pp ? 2 : 1; int freeSquares = 64 - d->groupLen[0] - (pp ? d->groupLen[1] : 0); uint64_t idx = 1; for (int k = 0; next < n || k == order[0] || k == order[1]; ++k) if (k == order[0]) // Leading pawns or pieces { d->groupIdx[0] = idx; idx *= e.hasPawns ? LeadPawnsSize[d->groupLen[0]][f] : e.hasUniquePieces ? 31332 : 462; } else if (k == order[1]) // Remaining pawns { d->groupIdx[1] = idx; idx *= Binomial[d->groupLen[1]][48 - d->groupLen[0]]; } else // Remainig pieces { d->groupIdx[next] = idx; idx *= Binomial[d->groupLen[next]][freeSquares]; freeSquares -= d->groupLen[next++]; } d->groupIdx[n] = idx; } // In Recursive Pairing each symbol represents a pair of childern symbols. So // read d->btree[] symbols data and expand each one in his left and right child // symbol until reaching the leafs that represent the symbol value. uint8_t set_symlen(PairsData* d, Sym s, std::vector& visited) { visited[s] = true; // We can set it now because tree is acyclic Sym sr = d->btree[s].get(); if (sr == 0xFFF) return 0; Sym sl = d->btree[s].get(); if (!visited[sl]) d->symlen[sl] = set_symlen(d, sl, visited); if (!visited[sr]) d->symlen[sr] = set_symlen(d, sr, visited); return d->symlen[sl] + d->symlen[sr] + 1; } uint8_t* set_sizes(PairsData* d, uint8_t* data) { d->flags = *data++; if (d->flags & TBFlag::SingleValue) { d->blocksNum = d->blockLengthSize = 0; d->span = d->sparseIndexSize = 0; // Broken MSVC zero-init d->minSymLen = *data++; // Here we store the single value return data; } // groupLen[] is a zero-terminated list of group lengths, the last groupIdx[] // element stores the biggest index that is the tb size. uint64_t tbSize = d->groupIdx[std::find(d->groupLen, d->groupLen + 7, 0) - d->groupLen]; d->sizeofBlock = 1ULL << *data++; d->span = 1ULL << *data++; d->sparseIndexSize = (tbSize + d->span - 1) / d->span; // Round up auto padding = number(data++); d->blocksNum = number(data); data += sizeof(uint32_t); d->blockLengthSize = d->blocksNum + padding; // Padded to ensure SparseIndex[] // does not point out of range. d->maxSymLen = *data++; d->minSymLen = *data++; d->lowestSym = (Sym*)data; d->base64.resize(d->maxSymLen - d->minSymLen + 1); // The canonical code is ordered such that longer symbols (in terms of // the number of bits of their Huffman code) have lower numeric value, // so that d->lowestSym[i] >= d->lowestSym[i+1] (when read as LittleEndian). // Starting from this we compute a base64[] table indexed by symbol length // and containing 64 bit values so that d->base64[i] >= d->base64[i+1]. // See http://www.eecs.harvard.edu/~michaelm/E210/huffman.pdf for (int i = d->base64.size() - 2; i >= 0; --i) { d->base64[i] = (d->base64[i + 1] + number(&d->lowestSym[i]) - number(&d->lowestSym[i + 1])) / 2; assert(d->base64[i] * 2 >= d->base64[i+1]); } // Now left-shift by an amount so that d->base64[i] gets shifted 1 bit more // than d->base64[i+1] and given the above assert condition, we ensure that // d->base64[i] >= d->base64[i+1]. Moreover for any symbol s64 of length i // and right-padded to 64 bits holds d->base64[i-1] >= s64 >= d->base64[i]. for (size_t i = 0; i < d->base64.size(); ++i) d->base64[i] <<= 64 - i - d->minSymLen; // Right-padding to 64 bits data += d->base64.size() * sizeof(Sym); d->symlen.resize(number(data)); data += sizeof(uint16_t); d->btree = (LR*)data; // The compression scheme used is "Recursive Pairing", that replaces the most // frequent adjacent pair of symbols in the source message by a new symbol, // reevaluating the frequencies of all of the symbol pairs with respect to // the extended alphabet, and then repeating the process. // See http://www.larsson.dogma.net/dcc99.pdf std::vector visited(d->symlen.size()); for (Sym sym = 0; sym < d->symlen.size(); ++sym) if (!visited[sym]) d->symlen[sym] = set_symlen(d, sym, visited); return data + d->symlen.size() * sizeof(LR) + (d->symlen.size() & 1); } uint8_t* set_dtz_map(TBTable&, uint8_t* data, File) { return data; } uint8_t* set_dtz_map(TBTable& e, uint8_t* data, File maxFile) { e.map = data; for (File f = FILE_A; f <= maxFile; ++f) { auto flags = e.get(0, f)->flags; if (flags & TBFlag::Mapped) { if (flags & TBFlag::Wide) { data += (uintptr_t)data & 1; // Word alignment, we may have a mixed table for (int i = 0; i < 4; ++i) { // Sequence like 3,x,x,x,1,x,0,2,x,x e.get(0, f)->map_idx[i] = (uint16_t)((uint16_t *)data - (uint16_t *)e.map + 1); data += 2 * number(data) + 2; } } else { for (int i = 0; i < 4; ++i) { e.get(0, f)->map_idx[i] = (uint16_t)(data - e.map + 1); data += *data + 1; } } } } return data += (uintptr_t)data & 1; // Word alignment } // Populate entry's PairsData records with data from the just memory mapped file. // Called at first access. template void set(T& e, uint8_t* data) { PairsData* d; enum { Split = 1, HasPawns = 2 }; assert(e.hasPawns == bool(*data & HasPawns)); assert((e.key != e.key2) == bool(*data & Split)); data++; // First byte stores flags const int sides = T::Sides == 2 && (e.key != e.key2) ? 2 : 1; const File maxFile = e.hasPawns ? FILE_D : FILE_A; bool pp = e.hasPawns && e.pawnCount[1]; // Pawns on both sides assert(!pp || e.pawnCount[0]); for (File f = FILE_A; f <= maxFile; ++f) { for (int i = 0; i < sides; i++) *e.get(i, f) = PairsData(); int order[][2] = { { *data & 0xF, pp ? *(data + 1) & 0xF : 0xF }, { *data >> 4, pp ? *(data + 1) >> 4 : 0xF } }; data += 1 + pp; for (int k = 0; k < e.pieceCount; ++k, ++data) for (int i = 0; i < sides; i++) { int p = i ? *data >> 4 : *data & 0xF; e.get(i, f)->pieces[k] = make_piece(Color(p >> 3), PieceType(p & 7)); } for (int i = 0; i < sides; ++i) set_groups(e, e.get(i, f), order[i], f); } data += (uintptr_t)data & 1; // Word alignment for (File f = FILE_A; f <= maxFile; ++f) for (int i = 0; i < sides; i++) data = set_sizes(e.get(i, f), data); data = set_dtz_map(e, data, maxFile); for (File f = FILE_A; f <= maxFile; ++f) for (int i = 0; i < sides; i++) { (d = e.get(i, f))->sparseIndex = (SparseEntry*)data; data += d->sparseIndexSize * sizeof(SparseEntry); } for (File f = FILE_A; f <= maxFile; ++f) for (int i = 0; i < sides; i++) { (d = e.get(i, f))->blockLength = (uint16_t*)data; data += d->blockLengthSize * sizeof(uint16_t); } for (File f = FILE_A; f <= maxFile; ++f) for (int i = 0; i < sides; i++) { data = (uint8_t*)(((uintptr_t)data + 0x3F) & ~0x3F); // 64 byte alignment (d = e.get(i, f))->data = data; data += d->blocksNum * d->sizeofBlock; } } // If the TB file corresponding to the given position is already memory mapped // then return its base address, otherwise try to memory map and init it. Called // at every probe, memory map and init only at first access. Function is thread // safe and can be called concurrently. template void* mapped(TBTable& e, const Position& pos) { static std::mutex mutex; // Use 'acquire' to avoid a thread reading 'ready' == true while // another is still working. (compiler reordering may cause this). if (e.ready.load(std::memory_order_acquire)) return e.baseAddress; // Could be nullptr if file does not exist std::unique_lock lk(mutex); if (e.ready.load(std::memory_order_relaxed)) // Recheck under lock return e.baseAddress; // Pieces strings in decreasing order for each color, like ("KPP","KR") std::string fname, w, b; for (PieceType pt = KING; pt >= PAWN; --pt) { w += std::string(popcount(pos.pieces(WHITE, pt)), PieceToChar[pt]); b += std::string(popcount(pos.pieces(BLACK, pt)), PieceToChar[pt]); } fname = (e.key == pos.material_key() ? w + 'v' + b : b + 'v' + w) + (Type == WDL ? ".rtbw" : ".rtbz"); uint8_t* data = TBFile(fname).map(&e.baseAddress, &e.mapping, Type); if (data) set(e, data); e.ready.store(true, std::memory_order_release); return e.baseAddress; } template::Ret> Ret probe_table(const Position& pos, ProbeState* result, WDLScore wdl = WDLDraw) { if (pos.count() == 2) // KvK return Ret(WDLDraw); TBTable* entry = TBTables.get(pos.material_key()); if (!entry || !mapped(*entry, pos)) return *result = FAIL, Ret(); return do_probe_table(pos, entry, wdl, result); } // For a position where the side to move has a winning capture it is not necessary // to store a winning value so the generator treats such positions as "don't cares" // and tries to assign to it a value that improves the compression ratio. Similarly, // if the side to move has a drawing capture, then the position is at least drawn. // If the position is won, then the TB needs to store a win value. But if the // position is drawn, the TB may store a loss value if that is better for compression. // All of this means that during probing, the engine must look at captures and probe // their results and must probe the position itself. The "best" result of these // probes is the correct result for the position. // DTZ tables do not store values when a following move is a zeroing winning move // (winning capture or winning pawn move). Also DTZ store wrong values for positions // where the best move is an ep-move (even if losing). So in all these cases set // the state to ZEROING_BEST_MOVE. template WDLScore search(Position& pos, ProbeState* result) { WDLScore value, bestValue = WDLLoss; StateInfo st; auto moveList = MoveList(pos); size_t totalCount = moveList.size(), moveCount = 0; for (const Move& move : moveList) { if ( !pos.capture(move) && (!CheckZeroingMoves || type_of(pos.moved_piece(move)) != PAWN)) continue; moveCount++; pos.do_move(move, st); value = -search(pos, result); pos.undo_move(move); if (*result == FAIL) return WDLDraw; if (value > bestValue) { bestValue = value; if (value >= WDLWin) { *result = ZEROING_BEST_MOVE; // Winning DTZ-zeroing move return value; } } } // In case we have already searched all the legal moves we don't have to probe // the TB because the stored score could be wrong. For instance TB tables // do not contain information on position with ep rights, so in this case // the result of probe_wdl_table is wrong. Also in case of only capture // moves, for instance here 4K3/4q3/6p1/2k5/6p1/8/8/8 w - - 0 7, we have to // return with ZEROING_BEST_MOVE set. bool noMoreMoves = (moveCount && moveCount == totalCount); if (noMoreMoves) value = bestValue; else { value = probe_table(pos, result); if (*result == FAIL) return WDLDraw; } // DTZ stores a "don't care" value if bestValue is a win if (bestValue >= value) return *result = ( bestValue > WDLDraw || noMoreMoves ? ZEROING_BEST_MOVE : OK), bestValue; return *result = OK, value; } } // namespace /// Tablebases::init() is called at startup and after every change to /// "SyzygyPath" UCI option to (re)create the various tables. It is not thread /// safe, nor it needs to be. void Tablebases::init(const std::string& paths) { TBTables.clear(); MaxCardinality = 0; TBFile::Paths = paths; #ifdef LARGEBOARDS // Tablebases are not working for large-board version return; #endif if (paths.empty() || paths == "") return; // MapB1H1H7[] encodes a square below a1-h8 diagonal to 0..27 int code = 0; for (Square s = SQ_A1; s <= SQ_H8; ++s) if (off_A1H8(s) < 0) MapB1H1H7[s] = code++; // MapA1D1D4[] encodes a square in the a1-d1-d4 triangle to 0..9 std::vector diagonal; code = 0; for (Square s = SQ_A1; s <= SQ_D4; ++s) if (off_A1H8(s) < 0 && file_of(s) <= FILE_D) MapA1D1D4[s] = code++; else if (!off_A1H8(s) && file_of(s) <= FILE_D) diagonal.push_back(s); // Diagonal squares are encoded as last ones for (auto s : diagonal) MapA1D1D4[s] = code++; // MapKK[] encodes all the 461 possible legal positions of two kings where // the first is in the a1-d1-d4 triangle. If the first king is on the a1-d4 // diagonal, the other one shall not to be above the a1-h8 diagonal. std::vector> bothOnDiagonal; code = 0; for (int idx = 0; idx < 10; idx++) for (Square s1 = SQ_A1; s1 <= SQ_D4; ++s1) if (MapA1D1D4[s1] == idx && (idx || s1 == SQ_B1)) // SQ_B1 is mapped to 0 { for (Square s2 = SQ_A1; s2 <= SQ_H8; ++s2) if ((PseudoAttacks[WHITE][KING][s1] | s1) & s2) continue; // Illegal position else if (!off_A1H8(s1) && off_A1H8(s2) > 0) continue; // First on diagonal, second above else if (!off_A1H8(s1) && !off_A1H8(s2)) bothOnDiagonal.emplace_back(idx, s2); else MapKK[idx][s2] = code++; } // Legal positions with both kings on diagonal are encoded as last ones for (auto p : bothOnDiagonal) MapKK[p.first][p.second] = code++; // Binomial[] stores the Binomial Coefficents using Pascal rule. There // are Binomial[k][n] ways to choose k elements from a set of n elements. Binomial[0][0] = 1; for (int n = 1; n < 64; n++) // Squares for (int k = 0; k < 6 && k <= n; ++k) // Pieces Binomial[k][n] = (k > 0 ? Binomial[k - 1][n - 1] : 0) + (k < n ? Binomial[k ][n - 1] : 0); // MapPawns[s] encodes squares a2-h7 to 0..47. This is the number of possible // available squares when the leading one is in 's'. Moreover the pawn with // highest MapPawns[] is the leading pawn, the one nearest the edge and, // among pawns with same file, the one with lowest rank. int availableSquares = 47; // Available squares when lead pawn is in a2 // Init the tables for the encoding of leading pawns group: with 7-men TB we // can have up to 5 leading pawns (KPPPPPK). for (int leadPawnsCnt = 1; leadPawnsCnt <= 5; ++leadPawnsCnt) for (File f = FILE_A; f <= FILE_D; ++f) { // Restart the index at every file because TB table is splitted // by file, so we can reuse the same index for different files. int idx = 0; // Sum all possible combinations for a given file, starting with // the leading pawn on rank 2 and increasing the rank. for (Rank r = RANK_2; r <= RANK_7; ++r) { Square sq = make_square(f, r); // Compute MapPawns[] at first pass. // If sq is the leading pawn square, any other pawn cannot be // below or more toward the edge of sq. There are 47 available // squares when sq = a2 and reduced by 2 for any rank increase // due to mirroring: sq == a3 -> no a2, h2, so MapPawns[a3] = 45 if (leadPawnsCnt == 1) { MapPawns[sq] = availableSquares--; MapPawns[sq ^ 7] = availableSquares--; // Horizontal flip } LeadPawnIdx[leadPawnsCnt][sq] = idx; idx += Binomial[leadPawnsCnt - 1][MapPawns[sq]]; } // After a file is traversed, store the cumulated per-file index LeadPawnsSize[leadPawnsCnt][f] = idx; } // Add entries in TB tables if the corresponding ".rtbw" file exsists for (PieceType p1 = PAWN; p1 <= QUEEN; ++p1) { TBTables.add({KING, p1, KING}); for (PieceType p2 = PAWN; p2 <= p1; ++p2) { TBTables.add({KING, p1, p2, KING}); TBTables.add({KING, p1, KING, p2}); for (PieceType p3 = PAWN; p3 <= QUEEN; ++p3) TBTables.add({KING, p1, p2, KING, p3}); for (PieceType p3 = PAWN; p3 <= p2; ++p3) { TBTables.add({KING, p1, p2, p3, KING}); for (PieceType p4 = PAWN; p4 <= p3; ++p4) { TBTables.add({KING, p1, p2, p3, p4, KING}); for (PieceType p5 = PAWN; p5 <= p4; ++p5) TBTables.add({KING, p1, p2, p3, p4, p5, KING}); for (PieceType p5 = PAWN; p5 <= QUEEN; ++p5) TBTables.add({KING, p1, p2, p3, p4, KING, p5}); } for (PieceType p4 = PAWN; p4 <= QUEEN; ++p4) { TBTables.add({KING, p1, p2, p3, KING, p4}); for (PieceType p5 = PAWN; p5 <= p4; ++p5) TBTables.add({KING, p1, p2, p3, KING, p4, p5}); } } for (PieceType p3 = PAWN; p3 <= p1; ++p3) for (PieceType p4 = PAWN; p4 <= (p1 == p3 ? p2 : p3); ++p4) TBTables.add({KING, p1, p2, KING, p3, p4}); } } sync_cout << "info string Found " << TBTables.size() << " tablebases" << sync_endl; } // Probe the WDL table for a particular position. // If *result != FAIL, the probe was successful. // The return value is from the point of view of the side to move: // -2 : loss // -1 : loss, but draw under 50-move rule // 0 : draw // 1 : win, but draw under 50-move rule // 2 : win WDLScore Tablebases::probe_wdl(Position& pos, ProbeState* result) { *result = OK; return search(pos, result); } // Probe the DTZ table for a particular position. // If *result != FAIL, the probe was successful. // The return value is from the point of view of the side to move: // n < -100 : loss, but draw under 50-move rule // -100 <= n < -1 : loss in n ply (assuming 50-move counter == 0) // -1 : loss, the side to move is mated // 0 : draw // 1 < n <= 100 : win in n ply (assuming 50-move counter == 0) // 100 < n : win, but draw under 50-move rule // // The return value n can be off by 1: a return value -n can mean a loss // in n+1 ply and a return value +n can mean a win in n+1 ply. This // cannot happen for tables with positions exactly on the "edge" of // the 50-move rule. // // This implies that if dtz > 0 is returned, the position is certainly // a win if dtz + 50-move-counter <= 99. Care must be taken that the engine // picks moves that preserve dtz + 50-move-counter <= 99. // // If n = 100 immediately after a capture or pawn move, then the position // is also certainly a win, and during the whole phase until the next // capture or pawn move, the inequality to be preserved is // dtz + 50-movecounter <= 100. // // In short, if a move is available resulting in dtz + 50-move-counter <= 99, // then do not accept moves leading to dtz + 50-move-counter == 100. int Tablebases::probe_dtz(Position& pos, ProbeState* result) { *result = OK; WDLScore wdl = search(pos, result); if (*result == FAIL || wdl == WDLDraw) // DTZ tables don't store draws return 0; // DTZ stores a 'don't care' value in this case, or even a plain wrong // one as in case the best move is a losing ep, so it cannot be probed. if (*result == ZEROING_BEST_MOVE) return dtz_before_zeroing(wdl); int dtz = probe_table(pos, result, wdl); if (*result == FAIL) return 0; if (*result != CHANGE_STM) return (dtz + 100 * (wdl == WDLBlessedLoss || wdl == WDLCursedWin)) * sign_of(wdl); // DTZ stores results for the other side, so we need to do a 1-ply search and // find the winning move that minimizes DTZ. StateInfo st; int minDTZ = 0xFFFF; for (const Move& move : MoveList(pos)) { bool zeroing = pos.capture(move) || type_of(pos.moved_piece(move)) == PAWN; pos.do_move(move, st); // For zeroing moves we want the dtz of the move _before_ doing it, // otherwise we will get the dtz of the next move sequence. Search the // position after the move to get the score sign (because even in a // winning position we could make a losing capture or going for a draw). dtz = zeroing ? -dtz_before_zeroing(search(pos, result)) : -probe_dtz(pos, result); // If the move mates, force minDTZ to 1 if (dtz == 1 && pos.checkers() && MoveList(pos).size() == 0) minDTZ = 1; // Convert result from 1-ply search. Zeroing moves are already accounted // by dtz_before_zeroing() that returns the DTZ of the previous move. if (!zeroing) dtz += sign_of(dtz); // Skip the draws and if we are winning only pick positive dtz if (dtz < minDTZ && sign_of(dtz) == sign_of(wdl)) minDTZ = dtz; pos.undo_move(move); if (*result == FAIL) return 0; } // When there are no legal moves, the position is mate: we return -1 return minDTZ == 0xFFFF ? -1 : minDTZ; } // Use the DTZ tables to rank root moves. // // A return value false indicates that not all probes were successful. bool Tablebases::root_probe(Position& pos, Search::RootMoves& rootMoves) { ProbeState result; StateInfo st; // Obtain 50-move counter for the root position int cnt50 = pos.rule50_count(); // Check whether a position was repeated since the last zeroing move. bool rep = pos.has_repeated(); int dtz, bound = Options["Syzygy50MoveRule"] ? 900 : 1; // Probe and rank each move for (auto& m : rootMoves) { pos.do_move(m.pv[0], st); // Calculate dtz for the current move counting from the root position if (pos.rule50_count() == 0) { // In case of a zeroing move, dtz is one of -101/-1/0/1/101 WDLScore wdl = -probe_wdl(pos, &result); dtz = dtz_before_zeroing(wdl); } else { // Otherwise, take dtz for the new position and correct by 1 ply dtz = -probe_dtz(pos, &result); dtz = dtz > 0 ? dtz + 1 : dtz < 0 ? dtz - 1 : dtz; } // Make sure that a mating move is assigned a dtz value of 1 if ( pos.checkers() && dtz == 2 && MoveList(pos).size() == 0) dtz = 1; pos.undo_move(m.pv[0]); if (result == FAIL) return false; // Better moves are ranked higher. Certain wins are ranked equally. // Losing moves are ranked equally unless a 50-move draw is in sight. int r = dtz > 0 ? (dtz + cnt50 <= 99 && !rep ? 1000 : 1000 - (dtz + cnt50)) : dtz < 0 ? (-dtz * 2 + cnt50 < 100 ? -1000 : -1000 + (-dtz + cnt50)) : 0; m.tbRank = r; // Determine the score to be displayed for this move. Assign at least // 1 cp to cursed wins and let it grow to 49 cp as the positions gets // closer to a real win. m.tbScore = r >= bound ? VALUE_MATE - MAX_PLY - 1 : r > 0 ? Value((std::max( 3, r - 800) * int(PawnValueEg)) / 200) : r == 0 ? VALUE_DRAW : r > -bound ? Value((std::min(-3, r + 800) * int(PawnValueEg)) / 200) : -VALUE_MATE + MAX_PLY + 1; } return true; } // Use the WDL tables to rank root moves. // This is a fallback for the case that some or all DTZ tables are missing. // // A return value false indicates that not all probes were successful. bool Tablebases::root_probe_wdl(Position& pos, Search::RootMoves& rootMoves) { static const int WDL_to_rank[] = { -1000, -899, 0, 899, 1000 }; ProbeState result; StateInfo st; bool rule50 = Options["Syzygy50MoveRule"]; // Probe and rank each move for (auto& m : rootMoves) { pos.do_move(m.pv[0], st); WDLScore wdl = -probe_wdl(pos, &result); pos.undo_move(m.pv[0]); if (result == FAIL) return false; m.tbRank = WDL_to_rank[wdl + 2]; if (!rule50) wdl = wdl > WDLDraw ? WDLWin : wdl < WDLDraw ? WDLLoss : WDLDraw; m.tbScore = WDL_to_value[wdl + 2]; } return true; } Fairy-Stockfish-fairy_sf_11_1/src/syzygy/tbprobe.h000066400000000000000000000047011366242550200223660ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (c) 2013 Ronald de Man Copyright (C) 2016-2020 Marco Costalba, Lucas Braesch Stockfish 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. Stockfish 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 . */ #ifndef TBPROBE_H #define TBPROBE_H #include #include "../search.h" namespace Tablebases { enum WDLScore { WDLLoss = -2, // Loss WDLBlessedLoss = -1, // Loss, but draw under 50-move rule WDLDraw = 0, // Draw WDLCursedWin = 1, // Win, but draw under 50-move rule WDLWin = 2, // Win WDLScoreNone = -1000 }; // Possible states after a probing operation enum ProbeState { FAIL = 0, // Probe failed (missing file table) OK = 1, // Probe succesful CHANGE_STM = -1, // DTZ should check the other side ZEROING_BEST_MOVE = 2 // Best move zeroes DTZ (capture or pawn move) }; extern int MaxCardinality; void init(const std::string& paths); WDLScore probe_wdl(Position& pos, ProbeState* result); int probe_dtz(Position& pos, ProbeState* result); bool root_probe(Position& pos, Search::RootMoves& rootMoves); bool root_probe_wdl(Position& pos, Search::RootMoves& rootMoves); void rank_root_moves(Position& pos, Search::RootMoves& rootMoves); inline std::ostream& operator<<(std::ostream& os, const WDLScore v) { os << (v == WDLLoss ? "Loss" : v == WDLBlessedLoss ? "Blessed loss" : v == WDLDraw ? "Draw" : v == WDLCursedWin ? "Cursed win" : v == WDLWin ? "Win" : "None"); return os; } inline std::ostream& operator<<(std::ostream& os, const ProbeState v) { os << (v == FAIL ? "Failed" : v == OK ? "Success" : v == CHANGE_STM ? "Probed opponent side" : v == ZEROING_BEST_MOVE ? "Best move zeroes DTZ" : "None"); return os; } } #endif Fairy-Stockfish-fairy_sf_11_1/src/thread.cpp000066400000000000000000000152341366242550200211600ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include // For std::count #include "movegen.h" #include "search.h" #include "thread.h" #include "uci.h" #include "syzygy/tbprobe.h" #include "tt.h" ThreadPool Threads; // Global object /// Thread constructor launches the thread and waits until it goes to sleep /// in idle_loop(). Note that 'searching' and 'exit' should be already set. Thread::Thread(size_t n) : idx(n), stdThread(&Thread::idle_loop, this) { wait_for_search_finished(); } /// Thread destructor wakes up the thread in idle_loop() and waits /// for its termination. Thread should be already waiting. Thread::~Thread() { assert(!searching); exit = true; start_searching(); stdThread.join(); } /// Thread::bestMoveCount(Move move) return best move counter for the given root move int Thread::best_move_count(Move move) { auto rm = std::find(rootMoves.begin() + pvIdx, rootMoves.begin() + pvLast, move); return rm != rootMoves.begin() + pvLast ? rm->bestMoveCount : 0; } /// Thread::clear() reset histories, usually before a new game void Thread::clear() { counterMoves.fill(MOVE_NONE); mainHistory.fill(0); captureHistory.fill(0); for (bool inCheck : { false, true }) for (StatsType c : { NoCaptures, Captures }) for (auto& to : continuationHistory[inCheck][c]) for (auto& h : to) h->fill(0); for (bool inCheck : { false, true }) for (StatsType c : { NoCaptures, Captures }) continuationHistory[inCheck][c][NO_PIECE][0]->fill(Search::CounterMovePruneThreshold - 1); } /// Thread::start_searching() wakes up the thread that will start the search void Thread::start_searching() { std::lock_guard lk(mutex); searching = true; cv.notify_one(); // Wake up the thread in idle_loop() } /// Thread::wait_for_search_finished() blocks on the condition variable /// until the thread has finished searching. void Thread::wait_for_search_finished() { std::unique_lock lk(mutex); cv.wait(lk, [&]{ return !searching; }); } /// Thread::idle_loop() is where the thread is parked, blocked on the /// condition variable, when it has no work to do. void Thread::idle_loop() { // If OS already scheduled us on a different group than 0 then don't overwrite // the choice, eventually we are one of many one-threaded processes running on // some Windows NUMA hardware, for instance in fishtest. To make it simple, // just check if running threads are below a threshold, in this case all this // NUMA machinery is not needed. if (Options["Threads"] > 8) WinProcGroup::bindThisThread(idx); while (true) { std::unique_lock lk(mutex); searching = false; cv.notify_one(); // Wake up anyone waiting for search finished cv.wait(lk, [&]{ return searching; }); if (exit) return; lk.unlock(); search(); } } /// ThreadPool::set() creates/destroys threads to match the requested number. /// Created and launched threads will immediately go to sleep in idle_loop. /// Upon resizing, threads are recreated to allow for binding if necessary. void ThreadPool::set(size_t requested) { if (size() > 0) { // destroy any existing thread(s) main()->wait_for_search_finished(); while (size() > 0) delete back(), pop_back(); } if (requested > 0) { // create new thread(s) push_back(new MainThread(0)); while (size() < requested) push_back(new Thread(size())); clear(); // Reallocate the hash with the new threadpool size TT.resize(Options["Hash"]); // Init thread number dependent search params. Search::init(); } } /// ThreadPool::clear() sets threadPool data to initial values. void ThreadPool::clear() { for (Thread* th : *this) th->clear(); main()->callsCnt = 0; main()->previousScore = VALUE_INFINITE; main()->previousTimeReduction = 1.0; } /// ThreadPool::start_thinking() wakes up main thread waiting in idle_loop() and /// returns immediately. Main thread will wake up other threads and start the search. void ThreadPool::start_thinking(Position& pos, StateListPtr& states, const Search::LimitsType& limits, bool ponderMode) { main()->wait_for_search_finished(); main()->stopOnPonderhit = stop = abort = false; increaseDepth = true; main()->ponder = ponderMode; Search::Limits = limits; Search::RootMoves rootMoves; for (const auto& m : MoveList(pos)) if ( (limits.searchmoves.empty() || std::count(limits.searchmoves.begin(), limits.searchmoves.end(), m)) && (limits.banmoves.empty() || !std::count(limits.banmoves.begin(), limits.banmoves.end(), m))) rootMoves.emplace_back(m); if (!rootMoves.empty()) Tablebases::rank_root_moves(pos, rootMoves); // After ownership transfer 'states' becomes empty, so if we stop the search // and call 'go' again without setting a new position states.get() == NULL. assert(states.get() || setupStates.get()); if (states.get()) setupStates = std::move(states); // Ownership transfer, states is now empty // We use Position::set() to set root position across threads. But there are // some StateInfo fields (previous, pliesFromNull, capturedPiece) that cannot // be deduced from a fen string, so set() clears them and to not lose the info // we need to backup and later restore setupStates->back(). Note that setupStates // is shared by threads but is accessed in read-only mode. StateInfo tmp = setupStates->back(); for (Thread* th : *this) { th->nodes = th->tbHits = th->nmpMinPly = 0; th->rootDepth = th->completedDepth = 0; th->rootMoves = rootMoves; th->rootPos.set(pos.variant(), pos.fen(), pos.is_chess960(), &setupStates->back(), th); } setupStates->back() = tmp; main()->start_searching(); } Fairy-Stockfish-fairy_sf_11_1/src/thread.h000066400000000000000000000071711366242550200206260ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef THREAD_H_INCLUDED #define THREAD_H_INCLUDED #include #include #include #include #include #include "material.h" #include "movepick.h" #include "pawns.h" #include "position.h" #include "search.h" #include "thread_win32_osx.h" /// Thread class keeps together all the thread-related stuff. We use /// per-thread pawn and material hash tables so that once we get a /// pointer to an entry its life time is unlimited and we don't have /// to care about someone changing the entry under our feet. class Thread { std::mutex mutex; std::condition_variable cv; size_t idx; bool exit = false, searching = true; // Set before starting std::thread NativeThread stdThread; public: explicit Thread(size_t); virtual ~Thread(); virtual void search(); void clear(); void idle_loop(); void start_searching(); void wait_for_search_finished(); int best_move_count(Move move); Pawns::Table pawnsTable; Material::Table materialTable; size_t pvIdx, pvLast; uint64_t ttHitAverage; int selDepth, nmpMinPly; Color nmpColor; std::atomic nodes, tbHits, bestMoveChanges; Position rootPos; Search::RootMoves rootMoves; Depth rootDepth, completedDepth; CounterMoveHistory counterMoves; ButterflyHistory mainHistory; CapturePieceToHistory captureHistory; ContinuationHistory continuationHistory[2][2]; Score contempt; }; /// MainThread is a derived class specific for main thread struct MainThread : public Thread { using Thread::Thread; void search() override; void check_time(); double previousTimeReduction; Value previousScore; Value iterValue[4]; int callsCnt; bool stopOnPonderhit; std::atomic_bool ponder; Thread* bestThread; // to fetch best move when in XBoard mode }; /// ThreadPool struct handles all the threads-related stuff like init, starting, /// parking and, most importantly, launching a thread. All the access to threads /// is done through this class. struct ThreadPool : public std::vector { void start_thinking(Position&, StateListPtr&, const Search::LimitsType&, bool = false); void clear(); void set(size_t); MainThread* main() const { return static_cast(front()); } uint64_t nodes_searched() const { return accumulate(&Thread::nodes); } uint64_t tb_hits() const { return accumulate(&Thread::tbHits); } std::atomic_bool stop, increaseDepth; std::atomic_bool abort, sit; StateListPtr setupStates; private: uint64_t accumulate(std::atomic Thread::* member) const { uint64_t sum = 0; for (Thread* th : *this) sum += (th->*member).load(std::memory_order_relaxed); return sum; } }; extern ThreadPool Threads; #endif // #ifndef THREAD_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/thread_win32_osx.h000066400000000000000000000043631366242550200225410ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef THREAD_WIN32_OSX_H_INCLUDED #define THREAD_WIN32_OSX_H_INCLUDED #include /// On OSX threads other than the main thread are created with a reduced stack /// size of 512KB by default, this is too low for deep searches, which require /// somewhat more than 1MB stack, so adjust it to TH_STACK_SIZE. /// The implementation calls pthread_create() with the stack size parameter /// equal to the linux 8MB default, on platforms that support it. #if defined(__APPLE__) || defined(__MINGW32__) || defined(__MINGW64__) #include static const size_t TH_STACK_SIZE = 8 * 1024 * 1024; template > void* start_routine(void* ptr) { P* p = reinterpret_cast(ptr); (p->first->*(p->second))(); // Call member function pointer delete p; return NULL; } class NativeThread { pthread_t thread; public: template> explicit NativeThread(void(T::*fun)(), T* obj) { pthread_attr_t attr_storage, *attr = &attr_storage; pthread_attr_init(attr); pthread_attr_setstacksize(attr, TH_STACK_SIZE); pthread_create(&thread, attr, start_routine, new P(obj, fun)); } void join() { pthread_join(thread, NULL); } }; #else // Default case: use STL classes typedef std::thread NativeThread; #endif #endif // #ifndef THREAD_WIN32_OSX_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/timeman.cpp000066400000000000000000000135051366242550200213420ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include #include "partner.h" #include "search.h" #include "timeman.h" #include "uci.h" TimeManagement Time; // Our global time management object namespace { enum TimeType { OptimumTime, MaxTime }; constexpr int MoveHorizon = 50; // Plan time management at most this many moves ahead constexpr double MaxRatio = 7.3; // When in trouble, we can step over reserved time with this ratio constexpr double StealRatio = 0.34; // However we must not steal time from remaining moves over this ratio // move_importance() is a skew-logistic function based on naive statistical // analysis of "how many games are still undecided after n half-moves". Game // is considered "undecided" as long as neither side has >275cp advantage. // Data was extracted from the CCRL game database with some simple filtering criteria. double move_importance(const Position& pos, int ply) { constexpr double XScale = 6.85; double XShift = (pos.max_rank() + 1) * (pos.max_file() + 1) / (1 + pos.must_capture()) + 0.5; constexpr double Skew = 0.171; return pow((1 + exp((ply - XShift) / XScale)), -Skew) + DBL_MIN; // Ensure non-zero } template TimePoint remaining(const Position& pos, TimePoint myTime, int movesToGo, int ply, TimePoint slowMover) { constexpr double TMaxRatio = (T == OptimumTime ? 1.0 : MaxRatio); constexpr double TStealRatio = (T == OptimumTime ? 0.0 : StealRatio); double moveImportance = (move_importance(pos, ply) * slowMover) / 100.0; double otherMovesImportance = 0.0; for (int i = 1; i < movesToGo; ++i) otherMovesImportance += move_importance(pos, ply + 2 * i); double ratio1 = (TMaxRatio * moveImportance) / (TMaxRatio * moveImportance + otherMovesImportance); double ratio2 = (moveImportance + TStealRatio * otherMovesImportance) / (moveImportance + otherMovesImportance); return TimePoint(myTime * std::min(ratio1, ratio2)); // Intel C++ asks for an explicit cast } } // namespace /// init() is called at the beginning of the search and calculates the allowed /// thinking time out of the time control and current game ply. We support four /// different kinds of time controls, passed in 'limits': /// /// inc == 0 && movestogo == 0 means: x basetime [sudden death!] /// inc == 0 && movestogo != 0 means: x moves in y minutes /// inc > 0 && movestogo == 0 means: x basetime + z increment /// inc > 0 && movestogo != 0 means: x moves in y minutes + z increment void TimeManagement::init(const Position& pos, Search::LimitsType& limits, Color us, int ply) { TimePoint minThinkingTime = Options["Minimum Thinking Time"]; TimePoint moveOverhead = Options["Move Overhead"]; TimePoint slowMover = Options["Slow Mover"]; TimePoint npmsec = Options["nodestime"]; TimePoint hypMyTime; // If we have to play in 'nodes as time' mode, then convert from time // to nodes, and use resulting values in time management formulas. // WARNING: to avoid time losses, the given npmsec (nodes per millisecond) // must be much lower than the real engine speed. if (npmsec) { if (!availableNodes) // Only once at game start availableNodes = npmsec * limits.time[us]; // Time is in msec // Convert from milliseconds to nodes limits.time[us] = TimePoint(availableNodes); limits.inc[us] *= npmsec; limits.npmsec = npmsec; } startTime = limits.startTime; optimumTime = maximumTime = std::max(limits.time[us], minThinkingTime); const int maxMTG = limits.movestogo ? std::min(limits.movestogo, MoveHorizon) : MoveHorizon; // We calculate optimum time usage for different hypothetical "moves to go" values // and choose the minimum of calculated search time values. Usually the greatest // hypMTG gives the minimum values. for (int hypMTG = 1; hypMTG <= maxMTG; ++hypMTG) { // Calculate thinking time for hypothetical "moves to go"-value hypMyTime = limits.time[us] + limits.inc[us] * (hypMTG - 1) - moveOverhead * (2 + std::min(hypMTG, 40)); // Adjust time management for four-player variants if (pos.two_boards()) { if (Partner.partnerDead && Partner.opptime) hypMyTime -= Partner.opptime * 10; else { hypMyTime = std::min(hypMyTime, 5000 + std::min(std::abs(limits.time[us] - Partner.opptime * 10), TimePoint(Partner.opptime * 10))); if (Partner.fast || Partner.partnerDead) hypMyTime /= 4; } } hypMyTime = std::max(hypMyTime, TimePoint(0)); TimePoint t1 = minThinkingTime + remaining(pos, hypMyTime, hypMTG, ply, slowMover); TimePoint t2 = minThinkingTime + remaining(pos, hypMyTime, hypMTG, ply, slowMover); optimumTime = std::min(t1, optimumTime); maximumTime = std::min(t2, maximumTime); } if (Options["Ponder"]) optimumTime += optimumTime / 4; } Fairy-Stockfish-fairy_sf_11_1/src/timeman.h000066400000000000000000000033421366242550200210050ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef TIMEMAN_H_INCLUDED #define TIMEMAN_H_INCLUDED #include "misc.h" #include "search.h" #include "thread.h" /// The TimeManagement class computes the optimal time to think depending on /// the maximum available time, the game move number and other parameters. class TimeManagement { public: void init(const Position& pos, Search::LimitsType& limits, Color us, int ply); TimePoint optimum() const { return optimumTime; } TimePoint maximum() const { return maximumTime; } TimePoint elapsed() const { return Search::Limits.npmsec ? TimePoint(Threads.nodes_searched()) : now() - startTime; } int64_t availableNodes; // When in 'nodes as time' mode private: TimePoint startTime; TimePoint optimumTime; TimePoint maximumTime; }; extern TimeManagement Time; #endif // #ifndef TIMEMAN_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/tt.cpp000066400000000000000000000126431366242550200203410ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include // For std::memset #include #include #include "bitboard.h" #include "misc.h" #include "thread.h" #include "tt.h" #include "uci.h" TranspositionTable TT; // Our global transposition table /// TTEntry::save populates the TTEntry with a new node's data, possibly /// overwriting an old position. Update is not atomic and can be racy. void TTEntry::save(Key k, Value v, bool pv, Bound b, Depth d, Move m, Value ev) { // Preserve any existing move for the same position if (m || (k >> 48) != key16) move32 = (uint32_t)m; // Overwrite less valuable entries if ( (k >> 48) != key16 || d - DEPTH_OFFSET > depth8 - 4 || b == BOUND_EXACT) { assert(d >= DEPTH_OFFSET); key16 = (uint16_t)(k >> 48); value16 = (int16_t)v; eval16 = (int16_t)ev; genBound8 = (uint8_t)(TT.generation8 | uint8_t(pv) << 2 | b); depth8 = (uint8_t)(d - DEPTH_OFFSET); } } /// TranspositionTable::resize() sets the size of the transposition table, /// measured in megabytes. Transposition table consists of a power of 2 number /// of clusters and each cluster consists of ClusterSize number of TTEntry. void TranspositionTable::resize(size_t mbSize) { Threads.main()->wait_for_search_finished(); clusterCount = mbSize * 1024 * 1024 / sizeof(Cluster); free(mem); mem = malloc(clusterCount * sizeof(Cluster) + CacheLineSize - 1); if (!mem) { std::cerr << "Failed to allocate " << mbSize << "MB for transposition table." << std::endl; exit(EXIT_FAILURE); } table = (Cluster*)((uintptr_t(mem) + CacheLineSize - 1) & ~(CacheLineSize - 1)); clear(); } /// TranspositionTable::clear() initializes the entire transposition table to zero, // in a multi-threaded way. void TranspositionTable::clear() { std::vector threads; for (size_t idx = 0; idx < Options["Threads"]; ++idx) { threads.emplace_back([this, idx]() { // Thread binding gives faster search on systems with a first-touch policy if (Options["Threads"] > 8) WinProcGroup::bindThisThread(idx); // Each thread will zero its part of the hash table const size_t stride = clusterCount / Options["Threads"], start = stride * idx, len = idx != Options["Threads"] - 1 ? stride : clusterCount - start; std::memset(&table[start], 0, len * sizeof(Cluster)); }); } for (std::thread& th: threads) th.join(); } /// TranspositionTable::probe() looks up the current position in the transposition /// table. It returns true and a pointer to the TTEntry if the position is found. /// Otherwise, it returns false and a pointer to an empty or least valuable TTEntry /// to be replaced later. The replace value of an entry is calculated as its depth /// minus 8 times its relative age. TTEntry t1 is considered more valuable than /// TTEntry t2 if its replace value is greater than that of t2. TTEntry* TranspositionTable::probe(const Key key, bool& found) const { TTEntry* const tte = first_entry(key); const uint16_t key16 = key >> 48; // Use the high 16 bits as key inside the cluster for (int i = 0; i < ClusterSize; ++i) if (!tte[i].key16 || tte[i].key16 == key16) { tte[i].genBound8 = uint8_t(generation8 | (tte[i].genBound8 & 0x7)); // Refresh return found = (bool)tte[i].key16, &tte[i]; } // Find an entry to be replaced according to the replacement strategy TTEntry* replace = tte; for (int i = 1; i < ClusterSize; ++i) // Due to our packed storage format for generation and its cyclic // nature we add 263 (256 is the modulus plus 7 to keep the unrelated // lowest three bits from affecting the result) to calculate the entry // age correctly even after generation8 overflows into the next cycle. if ( replace->depth8 - ((263 + generation8 - replace->genBound8) & 0xF8) > tte[i].depth8 - ((263 + generation8 - tte[i].genBound8) & 0xF8)) replace = &tte[i]; return found = false, replace; } /// TranspositionTable::hashfull() returns an approximation of the hashtable /// occupation during a search. The hash is x permill full, as per UCI protocol. int TranspositionTable::hashfull() const { int cnt = 0; for (int i = 0; i < 1000 / ClusterSize; ++i) for (int j = 0; j < ClusterSize; ++j) cnt += (table[i].entry[j].genBound8 & 0xF8) == generation8; return cnt * 1000 / (ClusterSize * (1000 / ClusterSize)); } Fairy-Stockfish-fairy_sf_11_1/src/tt.h000066400000000000000000000063121366242550200200020ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef TT_H_INCLUDED #define TT_H_INCLUDED #include "misc.h" #include "types.h" /// TTEntry struct is the 12 bytes transposition table entry, defined as below: /// /// move 32 bit /// key 16 bit /// value 16 bit /// eval value 16 bit /// generation 5 bit /// pv node 1 bit /// bound type 2 bit /// depth 8 bit struct TTEntry { Move move() const { return (Move )move32; } Value value() const { return (Value)value16; } Value eval() const { return (Value)eval16; } Depth depth() const { return (Depth)depth8 + DEPTH_OFFSET; } bool is_pv() const { return (bool)(genBound8 & 0x4); } Bound bound() const { return (Bound)(genBound8 & 0x3); } void save(Key k, Value v, bool pv, Bound b, Depth d, Move m, Value ev); private: friend class TranspositionTable; uint32_t move32; uint16_t key16; int16_t value16; int16_t eval16; uint8_t genBound8; uint8_t depth8; }; /// A TranspositionTable consists of a power of 2 number of clusters and each /// cluster consists of ClusterSize number of TTEntry. Each non-empty entry /// contains information of exactly one position. The size of a cluster should /// divide the size of a cache line size, to ensure that clusters never cross /// cache lines. This ensures best cache performance, as the cacheline is /// prefetched, as soon as possible. class TranspositionTable { static constexpr int CacheLineSize = 64; static constexpr int ClusterSize = 5; struct Cluster { TTEntry entry[ClusterSize]; char padding[4]; // Align to a divisor of the cache line size }; static_assert(CacheLineSize % sizeof(Cluster) == 0, "Cluster size incorrect"); public: ~TranspositionTable() { free(mem); } void new_search() { generation8 += 8; } // Lower 3 bits are used by PV flag and Bound TTEntry* probe(const Key key, bool& found) const; int hashfull() const; void resize(size_t mbSize); void clear(); // The 32 lowest order bits of the key are used to get the index of the cluster TTEntry* first_entry(const Key key) const { return &table[(uint32_t(key) * uint64_t(clusterCount)) >> 32].entry[0]; } private: friend struct TTEntry; size_t clusterCount; Cluster* table; void* mem; uint8_t generation8; // Size must be not bigger than TTEntry::genBound8 }; extern TranspositionTable TT; #endif // #ifndef TT_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/types.h000066400000000000000000000606751366242550200205330ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef TYPES_H_INCLUDED #define TYPES_H_INCLUDED /// When compiling with provided Makefile (e.g. for Linux and OSX), configuration /// is done automatically. To get started type 'make help'. /// /// When Makefile is not used (e.g. with Microsoft Visual Studio) some switches /// need to be set manually: /// /// -DNDEBUG | Disable debugging mode. Always use this for release. /// /// -DNO_PREFETCH | Disable use of prefetch asm-instruction. You may need this to /// | run on some very old machines. /// /// -DUSE_POPCNT | Add runtime support for use of popcnt asm-instruction. Works /// | only in 64-bit mode and requires hardware with popcnt support. /// /// -DUSE_PEXT | Add runtime support for use of pext asm-instruction. Works /// | only in 64-bit mode and requires hardware with pext support. #include #include #include #include #include #include #if defined(_MSC_VER) // Disable some silly and noisy warning from MSVC compiler #pragma warning(disable: 4127) // Conditional expression is constant #pragma warning(disable: 4146) // Unary minus operator applied to unsigned type #pragma warning(disable: 4800) // Forcing value to bool 'true' or 'false' #pragma comment(linker, "/STACK:8000000") // Use 8 MB stack size for MSVC #endif /// Predefined macros hell: /// /// __GNUC__ Compiler is gcc, Clang or Intel on Linux /// __INTEL_COMPILER Compiler is Intel /// _MSC_VER Compiler is MSVC or Intel on Windows /// _WIN32 Building on Windows (any) /// _WIN64 Building on Windows 64 bit #if defined(_WIN64) && defined(_MSC_VER) // No Makefile used # include // Microsoft header for _BitScanForward64() # define IS_64BIT #endif #if defined(USE_POPCNT) && (defined(__INTEL_COMPILER) || defined(_MSC_VER)) # include // Intel and Microsoft header for _mm_popcnt_u64() #endif #if !defined(NO_PREFETCH) && (defined(__INTEL_COMPILER) || defined(_MSC_VER)) # include // Intel and Microsoft header for _mm_prefetch() #endif #if defined(USE_PEXT) # include // Header for _pext_u64() intrinsic # ifdef LARGEBOARDS # define pext(b, m) (_pext_u64(b, m) ^ (_pext_u64(b >> 64, m >> 64) << popcount((m << 64) >> 64))) # else # define pext(b, m) _pext_u64(b, m) # endif #else # define pext(b, m) 0 #endif #ifdef USE_POPCNT constexpr bool HasPopCnt = true; #else constexpr bool HasPopCnt = false; #endif #ifdef USE_PEXT constexpr bool HasPext = true; #else constexpr bool HasPext = false; #endif #ifdef IS_64BIT constexpr bool Is64Bit = true; #else constexpr bool Is64Bit = false; #endif typedef uint64_t Key; #ifdef LARGEBOARDS #if defined(__GNUC__) && defined(IS_64BIT) typedef unsigned __int128 Bitboard; #else struct Bitboard { uint64_t b64[2]; constexpr Bitboard() : b64 {0, 0} {} constexpr Bitboard(uint64_t i) : b64 {0, i} {} constexpr Bitboard(uint64_t hi, uint64_t lo) : b64 {hi, lo} {}; constexpr operator bool() const { return b64[0] || b64[1]; } constexpr operator long long unsigned () const { return b64[1]; } constexpr operator unsigned() const { return b64[1]; } constexpr Bitboard operator << (const unsigned int bits) const { return Bitboard( bits >= 64 ? b64[1] << (bits - 64) : bits == 0 ? b64[0] : ((b64[0] << bits) | (b64[1] >> (64 - bits))), bits >= 64 ? 0 : b64[1] << bits); } constexpr Bitboard operator >> (const unsigned int bits) const { return Bitboard(bits >= 64 ? 0 : b64[0] >> bits, bits >= 64 ? b64[0] >> (bits - 64) : bits == 0 ? b64[1] : ((b64[1] >> bits) | (b64[0] << (64 - bits)))); } constexpr Bitboard operator << (const int bits) const { return *this << unsigned(bits); } constexpr Bitboard operator >> (const int bits) const { return *this >> unsigned(bits); } constexpr bool operator == (const Bitboard y) const { return (b64[0] == y.b64[0]) && (b64[1] == y.b64[1]); } constexpr bool operator != (const Bitboard y) const { return !(*this == y); } inline Bitboard& operator |=(const Bitboard x) { b64[0] |= x.b64[0]; b64[1] |= x.b64[1]; return *this; } inline Bitboard& operator &=(const Bitboard x) { b64[0] &= x.b64[0]; b64[1] &= x.b64[1]; return *this; } inline Bitboard& operator ^=(const Bitboard x) { b64[0] ^= x.b64[0]; b64[1] ^= x.b64[1]; return *this; } constexpr Bitboard operator ~ () const { return Bitboard(~b64[0], ~b64[1]); } constexpr Bitboard operator | (const Bitboard x) const { return Bitboard(b64[0] | x.b64[0], b64[1] | x.b64[1]); } constexpr Bitboard operator & (const Bitboard x) const { return Bitboard(b64[0] & x.b64[0], b64[1] & x.b64[1]); } constexpr Bitboard operator ^ (const Bitboard x) const { return Bitboard(b64[0] ^ x.b64[0], b64[1] ^ x.b64[1]); } constexpr Bitboard operator - (const Bitboard x) const { return Bitboard(b64[0] - x.b64[0] - (b64[1] < x.b64[1]), b64[1] - x.b64[1]); } constexpr Bitboard operator - (const int x) const { return *this - Bitboard(x); } inline Bitboard operator * (const Bitboard x) const { uint64_t a_lo = (uint32_t)b64[1]; uint64_t a_hi = b64[1] >> 32; uint64_t b_lo = (uint32_t)x.b64[1]; uint64_t b_hi = x.b64[1] >> 32; uint64_t t1 = (a_hi * b_lo) + ((a_lo * b_lo) >> 32); uint64_t t2 = (a_lo * b_hi) + (t1 & 0xFFFFFFFF); return Bitboard(b64[0] * x.b64[1] + b64[1] * x.b64[0] + (a_hi * b_hi) + (t1 >> 32) + (t2 >> 32), (t2 << 32) + (a_lo * b_lo & 0xFFFFFFFF)); } }; #endif constexpr int SQUARE_BITS = 7; #else typedef uint64_t Bitboard; constexpr int SQUARE_BITS = 6; #endif constexpr int MAX_MOVES = 1024; constexpr int MAX_PLY = 246; /// A move needs 16 bits to be stored /// /// bit 0- 5: destination square (from 0 to 63) /// bit 6-11: origin square (from 0 to 63) /// bit 12-13: promotion piece type - 2 (from KNIGHT-2 to QUEEN-2) /// bit 14-15: special move flag: promotion (1), en passant (2), castling (3) /// NOTE: EN-PASSANT bit is set only when a pawn can be captured /// /// Special cases are MOVE_NONE and MOVE_NULL. We can sneak these in because in /// any normal move destination square is always different from origin square /// while MOVE_NONE and MOVE_NULL have the same origin and destination square. enum Move : int { MOVE_NONE, MOVE_NULL = 1 + (1 << SQUARE_BITS) }; enum MoveType : int { NORMAL, ENPASSANT = 1 << (2 * SQUARE_BITS), CASTLING = 2 << (2 * SQUARE_BITS), PROMOTION = 3 << (2 * SQUARE_BITS), DROP = 4 << (2 * SQUARE_BITS), PIECE_PROMOTION = 5 << (2 * SQUARE_BITS), PIECE_DEMOTION = 6 << (2 * SQUARE_BITS), SPECIAL = 7 << (2 * SQUARE_BITS), }; constexpr int MOVE_TYPE_BITS = 4; enum Color { WHITE, BLACK, COLOR_NB = 2 }; enum CastlingRights { NO_CASTLING, WHITE_OO, WHITE_OOO = WHITE_OO << 1, BLACK_OO = WHITE_OO << 2, BLACK_OOO = WHITE_OO << 3, KING_SIDE = WHITE_OO | BLACK_OO, QUEEN_SIDE = WHITE_OOO | BLACK_OOO, WHITE_CASTLING = WHITE_OO | WHITE_OOO, BLACK_CASTLING = BLACK_OO | BLACK_OOO, ANY_CASTLING = WHITE_CASTLING | BLACK_CASTLING, CASTLING_RIGHT_NB = 16 }; enum CheckCount : int { CHECKS_0 = 0, CHECKS_NB = 11 }; enum MaterialCounting { NO_MATERIAL_COUNTING, JANGGI_MATERIAL, UNWEIGHTED_MATERIAL }; enum CountingRule { NO_COUNTING, MAKRUK_COUNTING, ASEAN_COUNTING }; enum Phase { PHASE_ENDGAME, PHASE_MIDGAME = 128, MG = 0, EG = 1, PHASE_NB = 2 }; enum ScaleFactor { SCALE_FACTOR_DRAW = 0, SCALE_FACTOR_NORMAL = 64, SCALE_FACTOR_MAX = 128, SCALE_FACTOR_NONE = 255 }; enum Bound { BOUND_NONE, BOUND_UPPER, BOUND_LOWER, BOUND_EXACT = BOUND_UPPER | BOUND_LOWER }; enum Value : int { VALUE_ZERO = 0, VALUE_DRAW = 0, VALUE_KNOWN_WIN = 10000, VALUE_MATE = 32000, XBOARD_VALUE_MATE = 200000, VALUE_INFINITE = 32001, VALUE_NONE = 32002, VALUE_MATE_IN_MAX_PLY = VALUE_MATE - 2 * MAX_PLY, VALUE_MATED_IN_MAX_PLY = -VALUE_MATE + 2 * MAX_PLY, PawnValueMg = 128, PawnValueEg = 213, KnightValueMg = 781, KnightValueEg = 854, BishopValueMg = 825, BishopValueEg = 915, RookValueMg = 1276, RookValueEg = 1380, QueenValueMg = 2538, QueenValueEg = 2682, FersValueMg = 420, FersValueEg = 450, AlfilValueMg = 330, AlfilValueEg = 300, FersAlfilValueMg = 700, FersAlfilValueEg = 650, SilverValueMg = 630, SilverValueEg = 630, AiwokValueMg = 2300, AiwokValueEg = 2700, BersValueMg = 2000, BersValueEg = 2000, ArchbishopValueMg = 2200, ArchbishopValueEg = 2200, ChancellorValueMg = 2300, ChancellorValueEg = 2600, AmazonValueMg = 2700, AmazonValueEg = 2850, KnibisValueMg = 1100, KnibisValueEg = 1200, BiskniValueMg = 750, BiskniValueEg = 700, KnirooValueMg = 1050, KnirooValueEg = 1250, RookniValueMg = 800, RookniValueEg = 950, ShogiPawnValueMg = 90, ShogiPawnValueEg = 100, LanceValueMg = 350, LanceValueEg = 250, ShogiKnightValueMg = 350, ShogiKnightValueEg = 300, EuroShogiKnightValueMg = 400, EuroShogiKnightValueEg = 400, GoldValueMg = 640, GoldValueEg = 640, DragonHorseValueMg = 1500, DragonHorseValueEg = 1500, ClobberPieceValueMg = 300, ClobberPieceValueEg = 300, BreakthroughPieceValueMg = 300, BreakthroughPieceValueEg = 300, ImmobilePieceValueMg = 100, ImmobilePieceValueEg = 100, CannonPieceValueMg = 800, CannonPieceValueEg = 700, JanggiCannonPieceValueMg = 800, JanggiCannonPieceValueEg = 600, SoldierValueMg = 200, SoldierValueEg = 270, HorseValueMg = 520, HorseValueEg = 800, ElephantValueMg = 300, ElephantValueEg = 300, JanggiElephantValueMg = 340, JanggiElephantValueEg = 350, BannerValueMg = 3400, BannerValueEg = 3500, WazirValueMg = 400, WazirValueEg = 350, CommonerValueMg = 700, CommonerValueEg = 900, CentaurValueMg = 1800, CentaurValueEg = 1900, MidgameLimit = 15258, EndgameLimit = 3915 }; constexpr int PIECE_TYPE_BITS = 6; // PIECE_TYPE_NB = pow(2, PIECE_TYPE_BITS) enum PieceType { NO_PIECE_TYPE, PAWN, KNIGHT, BISHOP, ROOK, QUEEN, FERS, MET = FERS, ALFIL, FERS_ALFIL, SILVER, KHON = SILVER, AIWOK, BERS, DRAGON = BERS, ARCHBISHOP, CHANCELLOR, AMAZON, KNIBIS, BISKNI, KNIROO, ROOKNI, SHOGI_PAWN, LANCE, SHOGI_KNIGHT, EUROSHOGI_KNIGHT, GOLD, DRAGON_HORSE, CLOBBER_PIECE, BREAKTHROUGH_PIECE, IMMOBILE_PIECE, CANNON, JANGGI_CANNON, SOLDIER, HORSE, ELEPHANT, JANGGI_ELEPHANT, BANNER, WAZIR, COMMONER, CENTAUR, KING, ALL_PIECES = 0, PIECE_TYPE_NB = 1 << PIECE_TYPE_BITS }; static_assert(KING < PIECE_TYPE_NB, "KING exceeds PIECE_TYPE_NB."); static_assert(PIECE_TYPE_BITS <= 6, "PIECE_TYPE uses more than 6 bit"); static_assert(!(PIECE_TYPE_NB & (PIECE_TYPE_NB - 1)), "PIECE_TYPE_NB is not a power of 2"); static_assert(2 * SQUARE_BITS + MOVE_TYPE_BITS + 2 * PIECE_TYPE_BITS <= 32, "Move encoding uses more than 32 bits"); enum Piece { NO_PIECE, PIECE_NB = 2 * PIECE_TYPE_NB }; enum RiderType { NO_RIDER = 0, RIDER_BISHOP = 1 << 0, RIDER_ROOK_H = 1 << 1, RIDER_ROOK_V = 1 << 2, RIDER_CANNON_H = 1 << 3, RIDER_CANNON_V = 1 << 4, RIDER_HORSE = 1 << 5, RIDER_ELEPHANT = 1 << 6, RIDER_JANGGI_ELEPHANT = 1 << 7, HOPPING_RIDERS = RIDER_CANNON_H | RIDER_CANNON_V, ASYMMETRICAL_RIDERS = RIDER_HORSE | RIDER_JANGGI_ELEPHANT, }; extern Value PieceValue[PHASE_NB][PIECE_NB]; typedef int Depth; enum : int { DEPTH_QS_CHECKS = 0, DEPTH_QS_NO_CHECKS = -1, DEPTH_QS_RECAPTURES = -5, DEPTH_NONE = -6, DEPTH_OFFSET = DEPTH_NONE, }; enum Square : int { #ifdef LARGEBOARDS SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1, SQ_I1, SQ_J1, SQ_K1, SQ_L1, SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2, SQ_I2, SQ_J2, SQ_K2, SQ_L2, SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3, SQ_I3, SQ_J3, SQ_K3, SQ_L3, SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4, SQ_I4, SQ_J4, SQ_K4, SQ_L4, SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5, SQ_I5, SQ_J5, SQ_K5, SQ_L5, SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6, SQ_I6, SQ_J6, SQ_K6, SQ_L6, SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7, SQ_I7, SQ_J7, SQ_K7, SQ_L7, SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8, SQ_I8, SQ_J8, SQ_K8, SQ_L8, SQ_A9, SQ_B9, SQ_C9, SQ_D9, SQ_E9, SQ_F9, SQ_G9, SQ_H9, SQ_I9, SQ_J9, SQ_K9, SQ_L9, SQ_A10, SQ_B10, SQ_C10, SQ_D10, SQ_E10, SQ_F10, SQ_G10, SQ_H10, SQ_I10, SQ_J10, SQ_K10, SQ_L10, #else SQ_A1, SQ_B1, SQ_C1, SQ_D1, SQ_E1, SQ_F1, SQ_G1, SQ_H1, SQ_A2, SQ_B2, SQ_C2, SQ_D2, SQ_E2, SQ_F2, SQ_G2, SQ_H2, SQ_A3, SQ_B3, SQ_C3, SQ_D3, SQ_E3, SQ_F3, SQ_G3, SQ_H3, SQ_A4, SQ_B4, SQ_C4, SQ_D4, SQ_E4, SQ_F4, SQ_G4, SQ_H4, SQ_A5, SQ_B5, SQ_C5, SQ_D5, SQ_E5, SQ_F5, SQ_G5, SQ_H5, SQ_A6, SQ_B6, SQ_C6, SQ_D6, SQ_E6, SQ_F6, SQ_G6, SQ_H6, SQ_A7, SQ_B7, SQ_C7, SQ_D7, SQ_E7, SQ_F7, SQ_G7, SQ_H7, SQ_A8, SQ_B8, SQ_C8, SQ_D8, SQ_E8, SQ_F8, SQ_G8, SQ_H8, #endif SQ_NONE, #ifdef LARGEBOARDS SQUARE_NB = 120, SQUARE_BIT_MASK = 127, #else SQUARE_NB = 64, SQUARE_BIT_MASK = 63, #endif SQ_MAX = SQUARE_NB - 1 }; enum Direction : int { #ifdef LARGEBOARDS NORTH = 12, #else NORTH = 8, #endif EAST = 1, SOUTH = -NORTH, WEST = -EAST, NORTH_EAST = NORTH + EAST, SOUTH_EAST = SOUTH + EAST, SOUTH_WEST = SOUTH + WEST, NORTH_WEST = NORTH + WEST }; enum File : int { #ifdef LARGEBOARDS FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, FILE_I, FILE_J, FILE_K, FILE_L, #else FILE_A, FILE_B, FILE_C, FILE_D, FILE_E, FILE_F, FILE_G, FILE_H, #endif FILE_NB, FILE_MAX = FILE_NB - 1 }; enum Rank : int { #ifdef LARGEBOARDS RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, RANK_9, RANK_10, #else RANK_1, RANK_2, RANK_3, RANK_4, RANK_5, RANK_6, RANK_7, RANK_8, #endif RANK_NB, RANK_MAX = RANK_NB - 1 }; /// Score enum stores a middlegame and an endgame value in a single integer (enum). /// The least significant 16 bits are used to store the middlegame value and the /// upper 16 bits are used to store the endgame value. We have to take care to /// avoid left-shifting a signed int to avoid undefined behavior. enum Score : int { SCORE_ZERO }; constexpr Score make_score(int mg, int eg) { return Score((int)((unsigned int)eg << 16) + mg); } /// Extracting the signed lower and upper 16 bits is not so trivial because /// according to the standard a simple cast to short is implementation defined /// and so is a right shift of a signed integer. inline Value eg_value(Score s) { union { uint16_t u; int16_t s; } eg = { uint16_t(unsigned(s + 0x8000) >> 16) }; return Value(eg.s); } inline Value mg_value(Score s) { union { uint16_t u; int16_t s; } mg = { uint16_t(unsigned(s)) }; return Value(mg.s); } #define ENABLE_BIT_OPERATORS_ON(T) \ inline T operator~ (T d) { return (T)~(int)d; } \ inline T operator| (T d1, T d2) { return (T)((int)d1 | (int)d2); } \ inline T operator& (T d1, T d2) { return (T)((int)d1 & (int)d2); } \ inline T operator^ (T d1, T d2) { return (T)((int)d1 ^ (int)d2); } \ inline T& operator|= (T& d1, T d2) { return (T&)((int&)d1 |= (int)d2); } \ inline T& operator&= (T& d1, T d2) { return (T&)((int&)d1 &= (int)d2); } \ inline T& operator^= (T& d1, T d2) { return (T&)((int&)d1 ^= (int)d2); } #define ENABLE_BASE_OPERATORS_ON(T) \ constexpr T operator+(T d1, T d2) { return T(int(d1) + int(d2)); } \ constexpr T operator-(T d1, T d2) { return T(int(d1) - int(d2)); } \ constexpr T operator-(T d) { return T(-int(d)); } \ inline T& operator+=(T& d1, T d2) { return d1 = d1 + d2; } \ inline T& operator-=(T& d1, T d2) { return d1 = d1 - d2; } #define ENABLE_INCR_OPERATORS_ON(T) \ inline T& operator++(T& d) { return d = T(int(d) + 1); } \ inline T& operator--(T& d) { return d = T(int(d) - 1); } #define ENABLE_FULL_OPERATORS_ON(T) \ ENABLE_BASE_OPERATORS_ON(T) \ constexpr T operator*(int i, T d) { return T(i * int(d)); } \ constexpr T operator*(T d, int i) { return T(int(d) * i); } \ constexpr T operator/(T d, int i) { return T(int(d) / i); } \ constexpr int operator/(T d1, T d2) { return int(d1) / int(d2); } \ inline T& operator*=(T& d, int i) { return d = T(int(d) * i); } \ inline T& operator/=(T& d, int i) { return d = T(int(d) / i); } ENABLE_FULL_OPERATORS_ON(Value) ENABLE_FULL_OPERATORS_ON(Direction) ENABLE_INCR_OPERATORS_ON(PieceType) ENABLE_INCR_OPERATORS_ON(Piece) ENABLE_INCR_OPERATORS_ON(Square) ENABLE_INCR_OPERATORS_ON(File) ENABLE_INCR_OPERATORS_ON(Rank) ENABLE_INCR_OPERATORS_ON(CheckCount) ENABLE_BASE_OPERATORS_ON(Score) ENABLE_BIT_OPERATORS_ON(RiderType) #undef ENABLE_FULL_OPERATORS_ON #undef ENABLE_INCR_OPERATORS_ON #undef ENABLE_BASE_OPERATORS_ON #undef ENABLE_BIT_OPERATORS_ON /// Additional operators to add integers to a Value constexpr Value operator+(Value v, int i) { return Value(int(v) + i); } constexpr Value operator-(Value v, int i) { return Value(int(v) - i); } inline Value& operator+=(Value& v, int i) { return v = v + i; } inline Value& operator-=(Value& v, int i) { return v = v - i; } /// Additional operators to add a Direction to a Square constexpr Square operator+(Square s, Direction d) { return Square(int(s) + int(d)); } constexpr Square operator-(Square s, Direction d) { return Square(int(s) - int(d)); } inline Square& operator+=(Square& s, Direction d) { return s = s + d; } inline Square& operator-=(Square& s, Direction d) { return s = s - d; } /// Only declared but not defined. We don't want to multiply two scores due to /// a very high risk of overflow. So user should explicitly convert to integer. Score operator*(Score, Score) = delete; /// Division of a Score must be handled separately for each term inline Score operator/(Score s, int i) { return make_score(mg_value(s) / i, eg_value(s) / i); } /// Multiplication of a Score by an integer. We check for overflow in debug mode. inline Score operator*(Score s, int i) { Score result = Score(int(s) * i); assert(eg_value(result) == (i * eg_value(s))); assert(mg_value(result) == (i * mg_value(s))); assert((i == 0) || (result / i) == s); return result; } /// Multiplication of a Score by a boolean inline Score operator*(Score s, bool b) { return Score(int(s) * int(b)); } constexpr Color operator~(Color c) { return Color(c ^ BLACK); // Toggle color } constexpr Square operator~(Square s) { #ifdef LARGEBOARDS return Square(s - FILE_NB * (s / FILE_NB * 2 - RANK_MAX)); // Vertical flip SQ_A1 -> SQ_A10 #else return Square(s ^ SQ_A8); // Vertical flip SQ_A1 -> SQ_A8 #endif } constexpr Piece operator~(Piece pc) { return Piece(pc ^ PIECE_TYPE_NB); // Swap color of piece BLACK KNIGHT -> WHITE KNIGHT } inline File map_to_queenside(File f) { return std::min(f, File(FILE_H - f)); // Map files ABCDEFGH to files ABCDDCBA } constexpr CastlingRights operator&(Color c, CastlingRights cr) { return CastlingRights((c == WHITE ? WHITE_CASTLING : BLACK_CASTLING) & cr); } constexpr Value mate_in(int ply) { return VALUE_MATE - ply; } constexpr Value mated_in(int ply) { return -VALUE_MATE + ply; } constexpr Value convert_mate_value(Value v, int ply) { return v == VALUE_MATE ? mate_in(ply) : v == -VALUE_MATE ? mated_in(ply) : v; } constexpr Square make_square(File f, Rank r) { return Square(r * FILE_NB + f); } constexpr Piece make_piece(Color c, PieceType pt) { return Piece((c << PIECE_TYPE_BITS) + pt); } constexpr PieceType type_of(Piece pc) { return PieceType(pc & (PIECE_TYPE_NB - 1)); } inline Color color_of(Piece pc) { assert(pc != NO_PIECE); return Color(pc >> PIECE_TYPE_BITS); } constexpr bool is_ok(Square s) { return s >= SQ_A1 && s <= SQ_MAX; } constexpr File file_of(Square s) { return File(s % FILE_NB); } constexpr Rank rank_of(Square s) { return Rank(s / FILE_NB); } constexpr Rank relative_rank(Color c, Rank r, Rank maxRank = RANK_8) { return Rank(c == WHITE ? r : maxRank - r); } constexpr Rank relative_rank(Color c, Square s, Rank maxRank = RANK_8) { return relative_rank(c, rank_of(s), maxRank); } constexpr Square relative_square(Color c, Square s, Rank maxRank = RANK_8) { return make_square(file_of(s), relative_rank(c, s, maxRank)); } constexpr Direction pawn_push(Color c) { return c == WHITE ? NORTH : SOUTH; } constexpr MoveType type_of(Move m) { return MoveType(m & (15 << (2 * SQUARE_BITS))); } constexpr Square to_sq(Move m) { return Square(m & SQUARE_BIT_MASK); } constexpr Square from_sq(Move m) { return type_of(m) == DROP ? SQ_NONE : Square((m >> SQUARE_BITS) & SQUARE_BIT_MASK); } inline int from_to(Move m) { return to_sq(m) + (from_sq(m) << SQUARE_BITS); } inline PieceType promotion_type(Move m) { return type_of(m) == PROMOTION ? PieceType((m >> (2 * SQUARE_BITS + MOVE_TYPE_BITS)) & (PIECE_TYPE_NB - 1)) : NO_PIECE_TYPE; } inline PieceType gating_type(Move m) { return PieceType((m >> (2 * SQUARE_BITS + MOVE_TYPE_BITS)) & (PIECE_TYPE_NB - 1)); } inline Square gating_square(Move m) { return Square((m >> (2 * SQUARE_BITS + MOVE_TYPE_BITS + PIECE_TYPE_BITS)) & SQUARE_BIT_MASK); } inline bool is_gating(Move m) { return gating_type(m) && (type_of(m) == NORMAL || type_of(m) == CASTLING); } inline bool is_pass(Move m) { return type_of(m) == SPECIAL && from_sq(m) == to_sq(m); } constexpr Move make_move(Square from, Square to) { return Move((from << SQUARE_BITS) + to); } template inline Move make(Square from, Square to, PieceType pt = NO_PIECE_TYPE) { return Move((pt << (2 * SQUARE_BITS + MOVE_TYPE_BITS)) + T + (from << SQUARE_BITS) + to); } constexpr Move make_drop(Square to, PieceType pt_in_hand, PieceType pt_dropped) { return Move((pt_in_hand << (2 * SQUARE_BITS + MOVE_TYPE_BITS + PIECE_TYPE_BITS)) + (pt_dropped << (2 * SQUARE_BITS + MOVE_TYPE_BITS)) + DROP + to); } constexpr Move reverse_move(Move m) { return make_move(to_sq(m), from_sq(m)); } template constexpr Move make_gating(Square from, Square to, PieceType pt, Square gate) { return Move((gate << (2 * SQUARE_BITS + MOVE_TYPE_BITS + PIECE_TYPE_BITS)) + (pt << (2 * SQUARE_BITS + MOVE_TYPE_BITS)) + T + (from << SQUARE_BITS) + to); } constexpr PieceType dropped_piece_type(Move m) { return PieceType((m >> (2 * SQUARE_BITS + MOVE_TYPE_BITS)) & (PIECE_TYPE_NB - 1)); } constexpr PieceType in_hand_piece_type(Move m) { return PieceType((m >> (2 * SQUARE_BITS + MOVE_TYPE_BITS + PIECE_TYPE_BITS)) & (PIECE_TYPE_NB - 1)); } inline bool is_ok(Move m) { return from_sq(m) != to_sq(m) || type_of(m) == PROMOTION || type_of(m) == SPECIAL; // Catch MOVE_NULL and MOVE_NONE } inline int dist(Direction d) { return std::abs(d % NORTH) < NORTH / 2 ? std::max(std::abs(d / NORTH), std::abs(d % NORTH)) : std::max(std::abs(d / NORTH) + 1, NORTH - std::abs(d % NORTH)); } #endif // #ifndef TYPES_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/uci.cpp000066400000000000000000000375121366242550200204740ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include #include #include "evaluate.h" #include "movegen.h" #include "position.h" #include "search.h" #include "thread.h" #include "timeman.h" #include "tt.h" #include "uci.h" #include "xboard.h" #include "syzygy/tbprobe.h" using namespace std; extern vector setup_bench(const Position&, istream&); namespace { // position() is called when engine receives the "position" UCI command. // The function sets up the position described in the given FEN string ("fen") // or the starting position ("startpos") and then makes the moves given in the // following move list ("moves"). void position(Position& pos, istringstream& is, StateListPtr& states) { Move m; string token, fen; is >> token; // Parse as SFEN if specified bool sfen = token == "sfen"; if (token == "startpos") { fen = variants.find(Options["UCI_Variant"])->second->startFen; is >> token; // Consume "moves" token if any } else if (token == "fen" || token == "sfen") while (is >> token && token != "moves") fen += token + " "; else return; states = StateListPtr(new std::deque(1)); // Drop old and create a new one pos.set(variants.find(Options["UCI_Variant"])->second, fen, Options["UCI_Chess960"], &states->back(), Threads.main(), sfen); // Parse move list (if any) while (is >> token && (m = UCI::to_move(pos, token)) != MOVE_NONE) { states->emplace_back(); pos.do_move(m, states->back()); } } // setoption() is called when engine receives the "setoption" UCI command. The // function updates the UCI option ("name") to the given value ("value"). void setoption(istringstream& is) { string token, name, value; is >> token; // Consume "name" token if (Options["Protocol"] == "ucci") name = token; else // Read option name (can contain spaces) while (is >> token && token != "value") name += (name.empty() ? "" : " ") + token; // Read option value (can contain spaces) while (is >> token) value += (value.empty() ? "" : " ") + token; if (Options.count(name)) Options[name] = value; else if (Options["Protocol"] == "ucci" && (std::replace(name.begin(), name.end(), '_', ' '), Options.count(name))) Options[name] = value; else sync_cout << "No such option: " << name << sync_endl; } // go() is called when engine receives the "go" UCI command. The function sets // the thinking time and other parameters from the input string, then starts // the search. void go(Position& pos, istringstream& is, StateListPtr& states, const std::vector& banmoves = {}) { Search::LimitsType limits; string token; bool ponderMode = false; limits.startTime = now(); // As early as possible! limits.banmoves = banmoves; while (is >> token) if (token == "searchmoves") while (is >> token) limits.searchmoves.push_back(UCI::to_move(pos, token)); else if (token == "wtime") is >> limits.time[WHITE]; else if (token == "btime") is >> limits.time[BLACK]; else if (token == "winc") is >> limits.inc[WHITE]; else if (token == "binc") is >> limits.inc[BLACK]; else if (token == "movestogo") is >> limits.movestogo; else if (token == "depth") is >> limits.depth; else if (token == "nodes") is >> limits.nodes; else if (token == "movetime") is >> limits.movetime; else if (token == "mate") is >> limits.mate; else if (token == "perft") is >> limits.perft; else if (token == "infinite") limits.infinite = 1; else if (token == "ponder") ponderMode = true; // UCCI commands else if (token == "time") is >> limits.time[pos.side_to_move()]; else if (token == "opptime") is >> limits.time[~pos.side_to_move()]; else if (token == "increment") is >> limits.inc[pos.side_to_move()]; else if (token == "oppinc") is >> limits.inc[~pos.side_to_move()]; // USI commands else if (token == "byoyomi") { int byoyomi = 0; is >> byoyomi; limits.inc[WHITE] = limits.inc[BLACK] = byoyomi; limits.time[WHITE] += byoyomi; limits.time[BLACK] += byoyomi; } Threads.start_thinking(pos, states, limits, ponderMode); } // bench() is called when engine receives the "bench" command. Firstly // a list of UCI commands is setup according to bench parameters, then // it is run one by one printing a summary at the end. void bench(Position& pos, istream& args, StateListPtr& states) { string token; uint64_t num, nodes = 0, cnt = 1; vector list = setup_bench(pos, args); num = count_if(list.begin(), list.end(), [](string s) { return s.find("go ") == 0 || s.find("eval") == 0; }); TimePoint elapsed = now(); for (const auto& cmd : list) { istringstream is(cmd); is >> skipws >> token; if (token == "go" || token == "eval") { cerr << "\nPosition: " << cnt++ << '/' << num << endl; if (token == "go") { go(pos, is, states); Threads.main()->wait_for_search_finished(); nodes += Threads.nodes_searched(); } else sync_cout << "\n" << Eval::trace(pos) << sync_endl; } else if (token == "setoption") setoption(is); else if (token == "position") position(pos, is, states); else if (token == "ucinewgame") { Search::clear(); elapsed = now(); } // Search::clear() may take some while } elapsed = now() - elapsed + 1; // Ensure positivity to avoid a 'divide by zero' dbg_print(); // Just before exiting cerr << "\n===========================" << "\nTotal time (ms) : " << elapsed << "\nNodes searched : " << nodes << "\nNodes/second : " << 1000 * nodes / elapsed << endl; } // load() is called when engine receives the "load" command. // The function reads variant configuration files. void load(istringstream& is) { string token; while (is >> token) Options["VariantPath"] = token; } // check() is called when engine receives the "check" command. // The function reads variant configuration files and validates them. void check(istringstream& is) { string token; while (is >> token) variants.parse(token); } } // namespace /// UCI::loop() waits for a command from stdin, parses it and calls the appropriate /// function. Also intercepts EOF from stdin to ensure gracefully exiting if the /// GUI dies unexpectedly. When called with some command line arguments, e.g. to /// run 'bench', once the command is executed the function returns immediately. /// In addition to the UCI ones, also some additional debug commands are supported. void UCI::loop(int argc, char* argv[]) { Position pos; string token, cmd; StateListPtr states(new std::deque(1)); assert(variants.find(Options["UCI_Variant"])->second != nullptr); pos.set(variants.find(Options["UCI_Variant"])->second, variants.find(Options["UCI_Variant"])->second->startFen, false, &states->back(), Threads.main()); for (int i = 1; i < argc; ++i) cmd += std::string(argv[i]) + " "; // XBoard state machine XBoard::StateMachine xboardStateMachine; // UCCI banmoves state std::vector banmoves = {}; do { if (argc == 1 && !getline(cin, cmd)) // Block here waiting for input or EOF cmd = "quit"; istringstream is(cmd); token.clear(); // Avoid a stale if getline() returns empty or blank line is >> skipws >> token; if ( token == "quit" || token == "stop") Threads.stop = true; // The GUI sends 'ponderhit' to tell us the user has played the expected move. // So 'ponderhit' will be sent if we were told to ponder on the same move the // user has played. We should continue searching but switch from pondering to // normal search. else if (token == "ponderhit") Threads.main()->ponder = false; // Switch to normal search else if (token == "uci" || token == "usi" || token == "ucci" || token == "xboard") { Options["Protocol"].set_default(token); string defaultVariant = string( token == "usi" ? "shogi" : token == "ucci" ? "xiangqi" : "chess"); Options["UCI_Variant"].set_default(defaultVariant); if (token != "xboard") sync_cout << "id name " << engine_info(true) << "\n" << Options << "\n" << token << "ok" << sync_endl; } else if (Options["Protocol"] == "xboard") xboardStateMachine.process_command(pos, token, is, states); else if (token == "setoption") setoption(is); // UCCI-specific banmoves command else if (token == "banmoves") while (is >> token) banmoves.push_back(UCI::to_move(pos, token)); else if (token == "go") go(pos, is, states, banmoves); else if (token == "position") position(pos, is, states), banmoves.clear(); else if (token == "ucinewgame" || token == "usinewgame" || token == "uccinewgame") Search::clear(); else if (token == "isready") sync_cout << "readyok" << sync_endl; // Additional custom non-UCI commands, mainly for debugging. // Do not use these commands during a search! else if (token == "flip") pos.flip(); else if (token == "bench") bench(pos, is, states); else if (token == "d") sync_cout << pos << sync_endl; else if (token == "eval") sync_cout << Eval::trace(pos) << sync_endl; else if (token == "compiler") sync_cout << compiler_info() << sync_endl; else if (token == "load") { load(is); argc = 1; } // continue reading stdin else if (token == "check") check(is); else sync_cout << "Unknown command: " << cmd << sync_endl; } while (token != "quit" && argc == 1); // Command line args are one-shot } /// UCI::value() converts a Value to a string suitable for use with the UCI /// protocol specification: /// /// cp The score from the engine's point of view in centipawns. /// mate Mate in y moves, not plies. If the engine is getting mated /// use negative values for y. string UCI::value(Value v) { assert(-VALUE_INFINITE < v && v < VALUE_INFINITE); stringstream ss; if (Options["Protocol"] == "xboard") { if (abs(v) < VALUE_MATE - MAX_PLY) ss << v * 100 / PawnValueEg; else ss << (v > 0 ? XBOARD_VALUE_MATE + VALUE_MATE - v + 1 : -XBOARD_VALUE_MATE - VALUE_MATE - v - 1) / 2; } else if (abs(v) < VALUE_MATE - MAX_PLY) ss << "cp " << v * 100 / PawnValueEg; else if (Options["Protocol"] == "usi") // In USI, mate distance is given in ply ss << "mate " << (v > 0 ? VALUE_MATE - v : -VALUE_MATE - v); else ss << "mate " << (v > 0 ? VALUE_MATE - v + 1 : -VALUE_MATE - v - 1) / 2; return ss.str(); } /// UCI::square() converts a Square to a string in algebraic notation (g1, a7, etc.) std::string UCI::square(const Position& pos, Square s) { #ifdef LARGEBOARDS if (Options["Protocol"] == "usi") return rank_of(s) < RANK_10 ? std::string{ char('1' + pos.max_file() - file_of(s)), char('a' + pos.max_rank() - rank_of(s)) } : std::string{ char('0' + (pos.max_file() - file_of(s) + 1) / 10), char('0' + (pos.max_file() - file_of(s) + 1) % 10), char('a' + pos.max_rank() - rank_of(s)) }; else if ((Options["Protocol"] == "xboard" || Options["Protocol"] == "ucci") && pos.max_rank() == RANK_10) return std::string{ char('a' + file_of(s)), char('0' + rank_of(s)) }; else return rank_of(s) < RANK_10 ? std::string{ char('a' + file_of(s)), char('1' + (rank_of(s) % 10)) } : std::string{ char('a' + file_of(s)), char('0' + ((rank_of(s) + 1) / 10)), char('0' + ((rank_of(s) + 1) % 10)) }; #else return Options["Protocol"] == "usi" ? std::string{ char('1' + pos.max_file() - file_of(s)), char('a' + pos.max_rank() - rank_of(s)) } : std::string{ char('a' + file_of(s)), char('1' + rank_of(s)) }; #endif } /// UCI::dropped_piece() generates a piece label string from a Move. string UCI::dropped_piece(const Position& pos, Move m) { assert(type_of(m) == DROP); if (dropped_piece_type(m) == pos.promoted_piece_type(in_hand_piece_type(m))) // Dropping as promoted piece return std::string{'+', pos.piece_to_char()[in_hand_piece_type(m)]}; else return std::string{pos.piece_to_char()[dropped_piece_type(m)]}; } /// UCI::move() converts a Move to a string in coordinate notation (g1f3, a7a8q). /// The only special case is castling, where we print in the e1g1 notation in /// normal chess mode, and in e1h1 notation in chess960 mode. Internally all /// castling moves are always encoded as 'king captures rook'. string UCI::move(const Position& pos, Move m) { Square from = from_sq(m); Square to = to_sq(m); if (m == MOVE_NONE) return Options["Protocol"] == "usi" ? "resign" : "(none)"; if (m == MOVE_NULL) return "0000"; if (is_pass(m) && Options["Protocol"] == "xboard") return "pass"; if (is_gating(m) && gating_square(m) == to) from = to_sq(m), to = from_sq(m); else if (type_of(m) == CASTLING && !pos.is_chess960()) to = make_square(to > from ? pos.castling_kingside_file() : pos.castling_queenside_file(), rank_of(from)); string move = (type_of(m) == DROP ? UCI::dropped_piece(pos, m) + (Options["Protocol"] == "usi" ? '*' : '@') : UCI::square(pos, from)) + UCI::square(pos, to); if (type_of(m) == PROMOTION) move += pos.piece_to_char()[make_piece(BLACK, promotion_type(m))]; else if (type_of(m) == PIECE_PROMOTION) move += '+'; else if (type_of(m) == PIECE_DEMOTION) move += '-'; else if (is_gating(m)) move += pos.piece_to_char()[make_piece(BLACK, gating_type(m))]; return move; } /// UCI::to_move() converts a string representing a move in coordinate notation /// (g1f3, a7a8q) to the corresponding legal Move, if any. Move UCI::to_move(const Position& pos, string& str) { if (str.length() == 5) { if (str[4] == '=') // shogi moves refraining from promotion might use equals sign str.pop_back(); else // Junior could send promotion piece in uppercase str[4] = char(tolower(str[4])); } for (const auto& m : MoveList(pos)) if (str == UCI::move(pos, m) || (is_pass(m) && str == UCI::square(pos, from_sq(m)) + UCI::square(pos, to_sq(m)))) return m; return MOVE_NONE; } Fairy-Stockfish-fairy_sf_11_1/src/uci.h000066400000000000000000000053501366242550200201340ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #ifndef UCI_H_INCLUDED #define UCI_H_INCLUDED #include #include #include #include "types.h" class Position; namespace UCI { class Option; /// Custom comparator because UCI options should be case insensitive struct CaseInsensitiveLess { bool operator() (const std::string&, const std::string&) const; }; /// Our options container is actually a std::map typedef std::map OptionsMap; /// Option class implements an option as defined by UCI protocol class Option { typedef void (*OnChange)(const Option&); public: Option(OnChange = nullptr); Option(bool v, OnChange = nullptr); Option(const char* v, OnChange = nullptr); Option(const char* v, const std::vector& variants, OnChange = nullptr); Option(double v, int minv, int maxv, OnChange = nullptr); Option& operator=(const std::string&); void operator<<(const Option&); operator double() const; operator std::string() const; bool operator==(const char*) const; bool operator!=(const char*) const; void set_combo(std::vector newComboValues); void set_default(std::string newDefault); const std::string get_type() const; private: friend std::ostream& operator<<(std::ostream&, const OptionsMap&); std::string defaultValue, currentValue, type; int min, max; std::vector comboValues; size_t idx; OnChange on_change; }; void init(OptionsMap&); void loop(int argc, char* argv[]); std::string value(Value v); std::string square(const Position& pos, Square s); std::string dropped_piece(const Position& pos, Move m); std::string move(const Position& pos, Move m); std::string pv(const Position& pos, Depth depth, Value alpha, Value beta); Move to_move(const Position& pos, std::string& str); } // namespace UCI extern UCI::OptionsMap Options; #endif // #ifndef UCI_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/ucioption.cpp000066400000000000000000000276241366242550200217300ustar00rootroot00000000000000/* Stockfish, a UCI chess playing engine derived from Glaurung 2.1 Copyright (C) 2004-2008 Tord Romstad (Glaurung author) Copyright (C) 2008-2015 Marco Costalba, Joona Kiiski, Tord Romstad Copyright (C) 2015-2020 Marco Costalba, Joona Kiiski, Gary Linscott, Tord Romstad Stockfish 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. Stockfish 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 . */ #include #include #include #include #include #include "misc.h" #include "piece.h" #include "search.h" #include "thread.h" #include "tt.h" #include "uci.h" #include "variant.h" #include "syzygy/tbprobe.h" using std::string; UCI::OptionsMap Options; // Global object namespace PSQT { void init(const Variant* v); } namespace UCI { // standard variants of XBoard/WinBoard std::set standard_variants = { "normal", "nocastle", "fischerandom", "knightmate", "3check", "makruk", "shatranj", "asean", "seirawan", "crazyhouse", "bughouse", "suicide", "giveaway", "losers", "capablanca", "gothic", "janus", "caparandom", "grand", "shogi", "xiangqi" }; /// 'On change' actions, triggered by an option's value change void on_clear_hash(const Option&) { Search::clear(); } void on_hash_size(const Option& o) { TT.resize(o); } void on_logger(const Option& o) { start_logger(o); } void on_threads(const Option& o) { Threads.set(o); } void on_tb_path(const Option& o) { Tablebases::init(o); } void on_variant_path(const Option& o) { variants.parse(o); Options["UCI_Variant"].set_combo(variants.get_keys()); } void on_variant_change(const Option &o) { const Variant* v = variants.find(o)->second; PSQT::init(v); // Do not send setup command for known variants if (standard_variants.find(o) != standard_variants.end()) return; int pocketsize = v->pieceDrops ? (v->pocketSize ? v->pocketSize : v->pieceTypes.size()) : 0; if (Options["Protocol"] == "xboard") { // Send setup command sync_cout << "setup (" << v->pieceToCharTable << ") " << v->maxFile + 1 << "x" << v->maxRank + 1 << "+" << pocketsize << "_" << v->variantTemplate << " " << v->startFen << sync_endl; // Send piece command with Betza notation // https://www.gnu.org/software/xboard/Betza.html for (PieceType pt : v->pieceTypes) { string suffix = pt == PAWN && v->doubleStep ? "ifmnD" : pt == KING && v->cambodianMoves ? "ismN" : pt == FERS && v->cambodianMoves ? "ifD" : ""; // Janggi palace moves if (v->diagonalLines) { PieceType pt2 = pt == KING ? v->kingType : pt; if (pt2 == WAZIR) suffix += "F"; else if (pt2 == SOLDIER) suffix += "fF"; else if (pt2 == ROOK) suffix += "B"; else if (pt2 == JANGGI_CANNON) suffix += "pB"; } // Castling if (pt == KING && v->castling) suffix += "O" + std::to_string((v->castlingKingsideFile - v->castlingQueensideFile) / 2); // Drop region if (v->pieceDrops) { if (pt == PAWN && !v->firstRankPawnDrops) suffix += "j"; else if (pt == SHOGI_PAWN && !v->shogiDoubledPawn) suffix += "f"; else if (pt == BISHOP && v->dropOppositeColoredBishop) suffix += "s"; suffix += "@" + std::to_string(pt == PAWN && !v->promotionZonePawnDrops ? v->promotionRank : v->maxRank + 1); } sync_cout << "piece " << v->pieceToChar[pt] << "& " << pieceMap.find(pt == KING ? v->kingType : pt)->second->betza << suffix << sync_endl; PieceType promType = v->promotedPieceType[pt]; if (promType) sync_cout << "piece +" << v->pieceToChar[pt] << "& " << pieceMap.find(promType)->second->betza << sync_endl; } } else sync_cout << "info string variant " << (std::string)o << " files " << v->maxFile + 1 << " ranks " << v->maxRank + 1 << " pocket " << pocketsize << " template " << v->variantTemplate << " startpos " << v->startFen << sync_endl; } /// Our case insensitive less() function as required by UCI protocol bool CaseInsensitiveLess::operator() (const string& s1, const string& s2) const { return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end(), [](char c1, char c2) { return tolower(c1) < tolower(c2); }); } /// init() initializes the UCI options to their hard-coded default values void init(OptionsMap& o) { // at most 2^32 clusters. constexpr int MaxHashMB = Is64Bit ? 131072 : 2048; o["Protocol"] << Option("uci", {"uci", "usi", "ucci", "xboard"}); o["Debug Log File"] << Option("", on_logger); o["Contempt"] << Option(24, -100, 100); o["Analysis Contempt"] << Option("Both", {"Both", "Off", "White", "Black"}); o["Threads"] << Option(1, 1, 512, on_threads); o["Hash"] << Option(16, 1, MaxHashMB, on_hash_size); o["Clear Hash"] << Option(on_clear_hash); o["Ponder"] << Option(false); o["MultiPV"] << Option(1, 1, 500); o["Skill Level"] << Option(20, -20, 20); o["Move Overhead"] << Option(30, 0, 5000); o["Minimum Thinking Time"] << Option(20, 0, 5000); o["Slow Mover"] << Option(84, 10, 1000); o["nodestime"] << Option(0, 0, 10000); o["UCI_Chess960"] << Option(false); o["UCI_Variant"] << Option("chess", variants.get_keys(), on_variant_change); o["UCI_AnalyseMode"] << Option(false); o["UCI_LimitStrength"] << Option(false); o["UCI_Elo"] << Option(1350, 1350, 2850); o["SyzygyPath"] << Option("", on_tb_path); o["SyzygyProbeDepth"] << Option(1, 1, 100); o["Syzygy50MoveRule"] << Option(true); o["SyzygyProbeLimit"] << Option(7, 0, 7); o["TsumeMode"] << Option(false); o["VariantPath"] << Option("", on_variant_path); } /// operator<<() is used to print all the options default values in chronological /// insertion order (the idx field) and in the format defined by the UCI protocol. std::ostream& operator<<(std::ostream& os, const OptionsMap& om) { if (Options["Protocol"] == "xboard") { for (size_t idx = 0; idx < om.size(); ++idx) for (const auto& it : om) if (it.second.idx == idx && it.first != "Protocol" && it.first != "UCI_Variant" && it.first != "Threads" && it.first != "Hash") { const Option& o = it.second; os << "\nfeature option=\"" << it.first << " -" << o.type; if (o.type == "string" || o.type == "combo") os << " " << o.defaultValue; else if (o.type == "check") os << " " << int(o.defaultValue == "true"); if (o.type == "combo") for (string value : o.comboValues) if (value != o.defaultValue) os << " /// " << value; if (o.type == "spin") os << " " << int(stof(o.defaultValue)) << " " << o.min << " " << o.max; os << "\""; break; } } else for (size_t idx = 0; idx < om.size(); ++idx) for (const auto& it : om) if (it.second.idx == idx) { const Option& o = it.second; if (Options["Protocol"] == "ucci") { string name = it.first; std::replace(name.begin(), name.end(), ' ', '_'); os << "\noption " << name << " type " << o.type; } else os << "\noption name " << it.first << " type " << o.type; if (o.type == "string" || o.type == "check" || o.type == "combo") os << " default " << o.defaultValue; if (o.type == "combo") for (string value : o.comboValues) os << " var " << value; if (o.type == "spin") os << " default " << int(stof(o.defaultValue)) << " min " << o.min << " max " << o.max; break; } return os; } /// Option class constructors and conversion operators Option::Option(const char* v, OnChange f) : type("string"), min(0), max(0), on_change(f) { defaultValue = currentValue = v; } Option::Option(const char* v, const std::vector& variants, OnChange f) : type("combo"), min(0), max(0), comboValues(variants), on_change(f) { defaultValue = currentValue = v; } Option::Option(bool v, OnChange f) : type("check"), min(0), max(0), on_change(f) { defaultValue = currentValue = (v ? "true" : "false"); } Option::Option(OnChange f) : type("button"), min(0), max(0), on_change(f) {} Option::Option(double v, int minv, int maxv, OnChange f) : type("spin"), min(minv), max(maxv), on_change(f) { defaultValue = currentValue = std::to_string(v); } Option::operator double() const { assert(type == "check" || type == "spin"); return (type == "spin" ? stof(currentValue) : currentValue == "true"); } Option::operator std::string() const { assert(type == "string" || type == "combo"); return currentValue; } bool Option::operator==(const char* s) const { assert(type == "combo"); return !CaseInsensitiveLess()(currentValue, s) && !CaseInsensitiveLess()(s, currentValue); } bool Option::operator!=(const char* s) const { assert(type == "combo"); return !(*this == s); } /// operator<<() inits options and assigns idx in the correct printing order void Option::operator<<(const Option& o) { static size_t insert_order = 0; *this = o; idx = insert_order++; } /// operator=() updates currentValue and triggers on_change() action. It's up to /// the GUI to check for option's limits, but we could receive the new value /// from the user by console window, so let's check the bounds anyway. Option& Option::operator=(const string& v) { assert(!type.empty()); if ( (type != "button" && v.empty()) || (type == "check" && v != "true" && v != "false") || (type == "combo" && (std::find(comboValues.begin(), comboValues.end(), v) == comboValues.end())) || (type == "spin" && (stof(v) < min || stof(v) > max))) return *this; if (type == "combo") { OptionsMap comboMap; // To have case insensitive compare for (string token : comboValues) comboMap[token] << Option(); if (!comboMap.count(v) || v == "var") return *this; } if (type != "button") currentValue = v; if (on_change) on_change(*this); return *this; } void Option::set_combo(std::vector newComboValues) { comboValues = newComboValues; } void Option::set_default(std::string newDefault) { defaultValue = currentValue = newDefault; } const std::string Option::get_type() const { return type; } } // namespace UCI Fairy-Stockfish-fairy_sf_11_1/src/variant.cpp000066400000000000000000001210761366242550200213570ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #include #include #include #include #include "parser.h" #include "piece.h" #include "variant.h" using std::string; VariantMap variants; // Global object namespace { // Define variant rules Variant* fairy_variant_base() { Variant* v = new Variant(); v->pieceToCharTable = "PNBRQ................Kpnbrq................k"; v->endgameEval = false; return v; } Variant* chess_variant() { Variant* v = fairy_variant_base(); v->endgameEval = true; return v; } Variant* chess960_variant() { Variant* v = chess_variant(); v->chess960 = true; return v; } Variant* nocastle_variant() { Variant* v = chess_variant(); v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1"; v->castling = false; return v; } Variant* fairy_variant() { Variant* v = chess_variant(); v->add_piece(SILVER, 's'); v->add_piece(FERS, 'f'); return v; } // Makruk (Thai Chess) Variant* makruk_variant() { Variant* v = chess_variant(); v->variantTemplate = "makruk"; v->pieceToCharTable = "PN.R.M....SKpn.r.m....sk"; v->remove_piece(BISHOP); v->remove_piece(QUEEN); v->add_piece(KHON, 's'); v->add_piece(MET, 'm'); v->startFen = "rnsmksnr/8/pppppppp/8/8/PPPPPPPP/8/RNSKMSNR w - - 0 1"; v->promotionRank = RANK_6; v->promotionPieceTypes = {MET}; v->doubleStep = false; v->castling = false; v->nMoveRule = 0; v->countingRule = MAKRUK_COUNTING; return v; } // Makpong (Defensive Chess) // A Makruk variant used for tie-breaks // https://www.mayhematics.com/v/vol8/vc64b.pdf, p. 177 Variant* makpong_variant() { Variant* v = makruk_variant(); v->makpongRule = true; return v; } Variant* cambodian_variant() { Variant* v = makruk_variant(); v->startFen = "rnsmksnr/8/pppppppp/8/8/PPPPPPPP/8/RNSKMSNR w DEde - 0 1"; v->gating = true; v->cambodianMoves = true; return v; } Variant* karouk_variant() { Variant* v = cambodian_variant(); v->checkCounting = true; return v; } Variant* asean_variant() { Variant* v = chess_variant(); v->remove_piece(BISHOP); v->remove_piece(QUEEN); v->add_piece(KHON, 'b'); v->add_piece(MET, 'q'); v->startFen = "rnbqkbnr/8/pppppppp/8/8/PPPPPPPP/8/RNBQKBNR w - - 0 1"; v->promotionPieceTypes = {ROOK, KNIGHT, KHON, MET}; v->doubleStep = false; v->castling = false; v->countingRule = ASEAN_COUNTING; return v; } Variant* aiwok_variant() { Variant* v = makruk_variant(); v->pieceToCharTable = "PN.R...A..SKpn.r...a..sk"; v->remove_piece(MET); v->add_piece(AIWOK, 'a'); v->startFen = "rnsaksnr/8/pppppppp/8/8/PPPPPPPP/8/RNSKASNR w - - 0 1"; v->promotionPieceTypes = {AIWOK}; return v; } Variant* shatranj_variant() { Variant* v = fairy_variant_base(); v->variantTemplate = "shatranj"; v->remove_piece(BISHOP); v->remove_piece(QUEEN); v->add_piece(ALFIL, 'b'); v->add_piece(FERS, 'q'); v->startFen = "rnbkqbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBKQBNR w - - 0 1"; v->promotionPieceTypes = {FERS}; v->doubleStep = false; v->castling = false; v->extinctionValue = -VALUE_MATE; v->extinctionClaim = true; v->extinctionPieceTypes = {ALL_PIECES}; v->extinctionPieceCount = 1; v->extinctionOpponentPieceCount = 2; v->stalemateValue = -VALUE_MATE; v->nMoveRule = 70; return v; } Variant* amazon_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBR..............AKpnbr..............ak"; v->remove_piece(QUEEN); v->add_piece(AMAZON, 'a'); v->startFen = "rnbakbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBAKBNR w KQkq - 0 1"; v->promotionPieceTypes = {AMAZON, ROOK, BISHOP, KNIGHT}; return v; } Variant* hoppelpoppel_variant() { Variant* v = chess_variant(); v->remove_piece(KNIGHT); v->remove_piece(BISHOP); v->add_piece(KNIBIS, 'n'); v->add_piece(BISKNI, 'b'); v->promotionPieceTypes = {QUEEN, ROOK, BISKNI, KNIBIS}; return v; } Variant* newzealand_variant() { Variant* v = chess_variant(); v->remove_piece(ROOK); v->remove_piece(KNIGHT); v->add_piece(ROOKNI, 'r'); v->add_piece(KNIROO, 'n'); v->castlingRookPiece = ROOKNI; v->promotionPieceTypes = {QUEEN, ROOKNI, BISHOP, KNIROO}; return v; } Variant* kingofthehill_variant() { Variant* v = fairy_variant_base(); v->flagPiece = KING; v->whiteFlag = make_bitboard(SQ_D4, SQ_E4, SQ_D5, SQ_E5); v->blackFlag = make_bitboard(SQ_D4, SQ_E4, SQ_D5, SQ_E5); v->flagMove = false; return v; } Variant* racingkings_variant() { Variant* v = fairy_variant_base(); v->startFen = "8/8/8/8/8/8/krbnNBRK/qrbnNBRQ w - - 0 1"; v->flagPiece = KING; v->whiteFlag = Rank8BB; v->blackFlag = Rank8BB; v->flagMove = true; v->castling = false; v->checking = false; return v; } Variant* knightmate_variant() { Variant* v = fairy_variant_base(); v->add_piece(COMMONER, 'm'); v->remove_piece(KNIGHT); v->startFen = "rmbqkbmr/pppppppp/8/8/8/8/PPPPPPPP/RMBQKBMR w KQkq - 0 1"; v->kingType = KNIGHT; v->promotionPieceTypes = {COMMONER, QUEEN, ROOK, BISHOP}; return v; } Variant* losers_variant() { Variant* v = fairy_variant_base(); v->checkmateValue = VALUE_MATE; v->stalemateValue = VALUE_MATE; v->extinctionValue = VALUE_MATE; v->extinctionPieceTypes = {ALL_PIECES}; v->extinctionPieceCount = 1; v->mustCapture = true; return v; } Variant* giveaway_variant() { Variant* v = fairy_variant_base(); v->variantTemplate = "giveaway"; v->remove_piece(KING); v->add_piece(COMMONER, 'k'); v->promotionPieceTypes = {COMMONER, QUEEN, ROOK, BISHOP, KNIGHT}; v->stalemateValue = VALUE_MATE; v->extinctionValue = VALUE_MATE; v->extinctionPieceTypes = {ALL_PIECES}; v->mustCapture = true; return v; } Variant* antichess_variant() { Variant* v = giveaway_variant(); v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w - - 0 1"; v->castling = false; return v; } Variant* suicide_variant() { Variant* v = antichess_variant(); v->stalematePieceCount = true; return v; } Variant* codrus_variant() { Variant* v = giveaway_variant(); v->promotionPieceTypes = {QUEEN, ROOK, BISHOP, KNIGHT}; v->extinctionPieceTypes = {COMMONER}; return v; } Variant* extinction_variant() { Variant* v = fairy_variant_base(); v->remove_piece(KING); v->add_piece(COMMONER, 'k'); v->promotionPieceTypes = {COMMONER, QUEEN, ROOK, BISHOP, KNIGHT}; v->extinctionValue = -VALUE_MATE; v->extinctionPieceTypes = {COMMONER, QUEEN, ROOK, BISHOP, KNIGHT, PAWN}; return v; } Variant* kinglet_variant() { Variant* v = extinction_variant(); v->promotionPieceTypes = {COMMONER}; v->extinctionPieceTypes = {PAWN}; return v; } // Three Kings Chess // https://github.com/cutechess/cutechess/blob/master/projects/lib/src/board/threekingsboard.h Variant* threekings_variant() { Variant* v = fairy_variant_base(); v->remove_piece(KING); v->add_piece(COMMONER, 'k'); v->startFen = "knbqkbnk/pppppppp/8/8/8/8/PPPPPPPP/KNBQKBNK w - - 0 1"; v->extinctionValue = -VALUE_MATE; v->extinctionPieceTypes = {COMMONER}; v->extinctionPieceCount = 2; return v; } Variant* horde_variant() { Variant* v = fairy_variant_base(); v->startFen = "rnbqkbnr/pppppppp/8/1PP2PP1/PPPPPPPP/PPPPPPPP/PPPPPPPP/PPPPPPPP w kq - 0 1"; v->firstRankDoubleSteps = true; v->extinctionValue = -VALUE_MATE; v->extinctionPieceTypes = {ALL_PIECES}; return v; } Variant* threecheck_variant() { Variant* v = fairy_variant_base(); v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 3+3 0 1"; v->checkCounting = true; return v; } Variant* fivecheck_variant() { Variant* v = threecheck_variant(); v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 5+5 0 1"; return v; } Variant* crazyhouse_variant() { Variant* v = fairy_variant_base(); v->variantTemplate = "crazyhouse"; v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR[] w KQkq - 0 1"; v->pieceDrops = true; v->capturesToHand = true; return v; } Variant* loop_variant() { Variant* v = crazyhouse_variant(); v->dropLoop = true; return v; } Variant* chessgi_variant() { Variant* v = loop_variant(); v->firstRankPawnDrops = true; return v; } Variant* bughouse_variant() { Variant* v = crazyhouse_variant(); v->variantTemplate = "bughouse"; v->twoBoards = true; v->capturesToHand = false; v->stalemateValue = -VALUE_MATE; return v; } // Koedem (Bughouse variant) // http://schachclub-oetigheim.de/wp-content/uploads/2016/04/Koedem-rules.pdf Variant* koedem_variant() { Variant* v = bughouse_variant(); v->remove_piece(KING); v->add_piece(COMMONER, 'k'); v->mustDrop = true; v->mustDropType = COMMONER; v->extinctionValue = -VALUE_MATE; v->extinctionPieceTypes = {COMMONER}; v->extinctionOpponentPieceCount = 2; // own all kings/commoners return v; } Variant* pocketknight_variant() { Variant* v = chess_variant(); v->variantTemplate = "bughouse"; v->pocketSize = 2; v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR[Nn] w KQkq - 0 1"; v->pieceDrops = true; v->capturesToHand = false; return v; } Variant* placement_variant() { Variant* v = chess_variant(); v->variantTemplate = "bughouse"; v->startFen = "8/pppppppp/8/8/8/8/PPPPPPPP/8[KQRRBBNNkqrrbbnn] w - - 0 1"; v->mustDrop = true; v->pieceDrops = true; v->capturesToHand = false; v->whiteDropRegion = Rank1BB; v->blackDropRegion = Rank8BB; v->dropOppositeColoredBishop = true; v->castlingDroppedPiece = true; return v; } Variant* sittuyin_variant() { Variant* v = makruk_variant(); v->variantTemplate = "bughouse"; v->pieceToCharTable = "PN.R.F....SKpn.r.f....sk"; v->startFen = "8/8/4pppp/pppp4/4PPPP/PPPP4/8/8[KFRRSSNNkfrrssnn] w - - 0 1"; v->remove_piece(MET); v->add_piece(MET, 'f'); v->mustDrop = true; v->pieceDrops = true; v->capturesToHand = false; v->whiteDropRegion = Rank1BB | Rank2BB | Rank3BB; v->blackDropRegion = Rank8BB | Rank7BB | Rank6BB; v->sittuyinRookDrop = true; v->promotionRank = RANK_1; // no regular promotions v->sittuyinPromotion = true; v->promotionLimit[FERS] = 1; v->immobilityIllegal = false; v->countingRule = ASEAN_COUNTING; v->nMoveRule = 50; return v; } Variant* seirawan_variant() { Variant* v = chess_variant(); v->variantTemplate = "seirawan"; v->pieceToCharTable = "PNBRQ.E..........H...Kpnbrq.e..........h...k"; v->add_piece(ARCHBISHOP, 'h'); v->add_piece(CHANCELLOR, 'e'); v->startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR[HEhe] w KQBCDFGkqbcdfg - 0 1"; v->gating = true; v->seirawanGating = true; v->promotionPieceTypes = {ARCHBISHOP, CHANCELLOR, QUEEN, ROOK, BISHOP, KNIGHT}; return v; } Variant* shouse_variant() { Variant* v = seirawan_variant(); v->variantTemplate = "crazyhouse"; v->pieceDrops = true; v->capturesToHand = true; return v; } Variant* minishogi_variant_base() { Variant* v = fairy_variant_base(); v->variantTemplate = "shogi"; v->maxRank = RANK_5; v->maxFile = FILE_E; v->reset_pieces(); v->add_piece(SHOGI_PAWN, 'p'); v->add_piece(SILVER, 's'); v->add_piece(GOLD, 'g'); v->add_piece(BISHOP, 'b'); v->add_piece(DRAGON_HORSE, 'h'); v->add_piece(ROOK, 'r'); v->add_piece(DRAGON, 'd'); v->add_piece(KING, 'k'); v->startFen = "rbsgk/4p/5/P4/KGSBR[-] w 0 1"; v->pieceDrops = true; v->capturesToHand = true; v->promotionRank = RANK_5; v->promotionPieceTypes = {}; v->doubleStep = false; v->castling = false; v->promotedPieceType[SHOGI_PAWN] = GOLD; v->promotedPieceType[SILVER] = GOLD; v->promotedPieceType[BISHOP] = DRAGON_HORSE; v->promotedPieceType[ROOK] = DRAGON; v->shogiDoubledPawn = false; v->immobilityIllegal = true; v->shogiPawnDropMateIllegal = true; v->stalemateValue = -VALUE_MATE; v->nFoldRule = 4; v->nMoveRule = 0; v->perpetualCheckIllegal = true; return v; } Variant* minishogi_variant() { Variant* v = minishogi_variant_base(); v->pieceToCharTable = "P.BR.S...G.+.++.+Kp.br.s...g.+.++.+k"; v->pocketSize = 5; v->nFoldValue = -VALUE_MATE; v->nFoldValueAbsolute = true; return v; } Variant* kyotoshogi_variant() { Variant* v = minishogi_variant_base(); v->add_piece(LANCE, 'l'); v->add_piece(SHOGI_KNIGHT, 'n'); v->startFen = "p+nks+l/5/5/5/+LSK+NP[-] w 0 1"; v->promotionRank = RANK_1; v->mandatoryPiecePromotion = true; v->pieceDemotion = true; v->dropPromoted = true; v->promotedPieceType[LANCE] = GOLD; v->promotedPieceType[SILVER] = BISHOP; v->promotedPieceType[SHOGI_KNIGHT] = GOLD; v->promotedPieceType[SHOGI_PAWN] = ROOK; v->promotedPieceType[GOLD] = NO_PIECE_TYPE; v->promotedPieceType[BISHOP] = NO_PIECE_TYPE; v->promotedPieceType[ROOK] = NO_PIECE_TYPE; v->immobilityIllegal = false; v->shogiPawnDropMateIllegal = false; v->shogiDoubledPawn = true; return v; } Variant* microshogi_variant() { Variant* v = kyotoshogi_variant(); v->maxFile = FILE_D; v->startFen = "kb+r+l/p3/4/3P/+L+RBK[-] w 0 1"; v->promotionRank = RANK_1; v->piecePromotionOnCapture = true; v->promotedPieceType[LANCE] = SILVER; v->promotedPieceType[BISHOP] = GOLD; v->promotedPieceType[ROOK] = GOLD; v->promotedPieceType[SHOGI_PAWN] = SHOGI_KNIGHT; v->promotedPieceType[SILVER] = NO_PIECE_TYPE; v->promotedPieceType[GOLD] = NO_PIECE_TYPE; v->promotedPieceType[SHOGI_KNIGHT] = NO_PIECE_TYPE; return v; } Variant* dobutsu_variant() { Variant* v = minishogi_variant_base(); v->pieceToCharTable = "C....E...G.+.....Lc....e...g.+.....l"; v->pocketSize = 3; v->maxRank = RANK_4; v->maxFile = FILE_C; v->reset_pieces(); v->add_piece(SHOGI_PAWN, 'c'); v->add_piece(GOLD, 'h'); v->add_piece(FERS, 'e'); v->add_piece(WAZIR, 'g'); v->add_piece(KING, 'l'); v->startFen = "gle/1c1/1C1/ELG[-] w 0 1"; v->promotionRank = RANK_4; v->immobilityIllegal = false; v->shogiPawnDropMateIllegal = false; v->flagPiece = KING; v->whiteFlag = Rank4BB; v->blackFlag = Rank1BB; v->shogiDoubledPawn = true; return v; } Variant* gorogoroshogi_variant() { Variant* v = minishogi_variant_base(); v->pieceToCharTable = "P....S...G.+....+Kp....s...g.+....+k"; v->pocketSize = 3; v->maxRank = RANK_6; v->maxFile = FILE_E; v->startFen = "sgkgs/5/1ppp1/1PPP1/5/SGKGS[-] w 0 1"; v->promotionRank = RANK_5; return v; } Variant* judkinsshogi_variant() { Variant* v = minishogi_variant_base(); v->pieceToCharTable = "PNBR.S...G.++++.+Kpnbr.s...g.++++.+k"; v->maxRank = RANK_6; v->maxFile = FILE_F; v->add_piece(SHOGI_KNIGHT, 'n'); v->startFen = "rbnsgk/5p/6/6/P5/KGSNBR[-] w 0 1"; v->promotionRank = RANK_5; v->promotedPieceType[SHOGI_KNIGHT] = GOLD; return v; } Variant* euroshogi_variant() { Variant* v = minishogi_variant_base(); v->pieceToCharTable = "PNBR.....G.++++Kpnbr.....g.++++k"; v->maxRank = RANK_8; v->maxFile = FILE_H; v->add_piece(EUROSHOGI_KNIGHT, 'n'); v->startFen = "1nbgkgn1/1r4b1/pppppppp/8/8/PPPPPPPP/1B4R1/1NGKGBN1[-] w 0 1"; v->promotionRank = RANK_6; v->promotedPieceType[EUROSHOGI_KNIGHT] = GOLD; v->mandatoryPiecePromotion = true; return v; } Variant* losalamos_variant() { Variant* v = fairy_variant_base(); v->pieceToCharTable = "PN.RQ................Kpn.rq................k"; v->maxRank = RANK_6; v->maxFile = FILE_F; v->remove_piece(BISHOP); v->startFen = "rnqknr/pppppp/6/6/PPPPPP/RNQKNR w - - 0 1"; v->promotionRank = RANK_6; v->promotionPieceTypes = {QUEEN, ROOK, KNIGHT}; v->doubleStep = false; v->castling = false; return v; } Variant* gardner_variant() { Variant* v = fairy_variant_base(); v->maxRank = RANK_5; v->maxFile = FILE_E; v->startFen = "rnbqk/ppppp/5/PPPPP/RNBQK w - - 0 1"; v->promotionRank = RANK_5; v->doubleStep = false; v->castling = false; return v; } Variant* almost_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBR............CKpnbr............ck"; v->remove_piece(QUEEN); v->add_piece(CHANCELLOR, 'c'); v->startFen = "rnbckbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBCKBNR w KQkq - 0 1"; v->promotionPieceTypes = {CHANCELLOR, ROOK, BISHOP, KNIGHT}; return v; } Variant* chigorin_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBR............CKpnbrq............k"; v->add_piece(CHANCELLOR, 'c'); v->startFen = "rbbqkbbr/pppppppp/8/8/8/8/PPPPPPPP/RNNCKNNR w KQkq - 0 1"; v->promotionPieceTypes = {QUEEN, CHANCELLOR, ROOK, BISHOP, KNIGHT}; return v; } Variant* shatar_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBR..........J......Kpnbr..........j......k"; v->remove_piece(QUEEN); v->add_piece(BERS, 'j'); v->startFen = "rnbjkbnr/ppp1pppp/8/3p4/3P4/8/PPP1PPPP/RNBJKBNR w - - 0 1"; v->promotionPieceTypes = {BERS}; v->doubleStep = false; v->castling = false; v->extinctionValue = VALUE_DRAW; // Robado v->extinctionPieceTypes = {ALL_PIECES}; v->extinctionPieceCount = 1; v->shatarMateRule = true; return v; } Variant* clobber_variant() { Variant* v = fairy_variant_base(); v->pieceToCharTable = "P.................p................."; v->maxRank = RANK_6; v->maxFile = FILE_E; v->reset_pieces(); v->add_piece(CLOBBER_PIECE, 'p'); v->startFen = "PpPpP/pPpPp/PpPpP/pPpPp/PpPpP/pPpPp w 0 1"; v->promotionPieceTypes = {}; v->doubleStep = false; v->castling = false; v->stalemateValue = -VALUE_MATE; v->immobilityIllegal = false; return v; } Variant* breakthrough_variant() { Variant* v = fairy_variant_base(); v->pieceToCharTable = "P.................p................."; v->reset_pieces(); v->add_piece(BREAKTHROUGH_PIECE, 'p'); v->startFen = "pppppppp/pppppppp/8/8/8/8/PPPPPPPP/PPPPPPPP w 0 1"; v->promotionPieceTypes = {}; v->firstRankDoubleSteps = false; v->castling = false; v->stalemateValue = -VALUE_MATE; v->flagPiece = BREAKTHROUGH_PIECE; v->whiteFlag = Rank8BB; v->blackFlag = Rank1BB; return v; } Variant* minixiangqi_variant() { Variant* v = fairy_variant_base(); v->variantTemplate = "xiangqi"; v->pieceToCharTable = "PN.R.....K.C.pn.r.....k.c."; v->maxRank = RANK_7; v->maxFile = FILE_G; v->reset_pieces(); v->add_piece(ROOK, 'r'); v->add_piece(HORSE, 'n', 'h'); v->add_piece(KING, 'k'); v->add_piece(CANNON, 'c'); v->add_piece(SOLDIER, 'p'); v->startFen = "rcnkncr/p1ppp1p/7/7/7/P1PPP1P/RCNKNCR w - - 0 1"; Bitboard white_castle = make_bitboard(SQ_C1, SQ_D1, SQ_E1, SQ_C2, SQ_D2, SQ_E2, SQ_C3, SQ_D3, SQ_E3); Bitboard black_castle = make_bitboard(SQ_C5, SQ_D5, SQ_E5, SQ_C6, SQ_D6, SQ_E6, SQ_C7, SQ_D7, SQ_E7); v->mobilityRegion[WHITE][KING] = white_castle; v->mobilityRegion[BLACK][KING] = black_castle; v->kingType = WAZIR; v->promotionPieceTypes = {}; v->doubleStep = false; v->castling = false; v->stalemateValue = -VALUE_MATE; //v->nFoldValue = VALUE_MATE; v->perpetualCheckIllegal = true; v->flyingGeneral = true; return v; } #ifdef LARGEBOARDS Variant* shogi_variant() { Variant* v = minishogi_variant_base(); v->maxRank = RANK_9; v->maxFile = FILE_I; v->add_piece(LANCE, 'l'); v->add_piece(SHOGI_KNIGHT, 'n'); v->startFen = "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL[-] w 0 1"; v->promotionRank = RANK_7; v->promotedPieceType[LANCE] = GOLD; v->promotedPieceType[SHOGI_KNIGHT] = GOLD; return v; } Variant* capablanca_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBRQ..AC............Kpnbrq..ac............k"; v->maxRank = RANK_8; v->maxFile = FILE_J; v->castlingKingsideFile = FILE_I; v->castlingQueensideFile = FILE_C; v->add_piece(ARCHBISHOP, 'a'); v->add_piece(CHANCELLOR, 'c'); v->startFen = "rnabqkbcnr/pppppppppp/10/10/10/10/PPPPPPPPPP/RNABQKBCNR w KQkq - 0 1"; v->promotionPieceTypes = {ARCHBISHOP, CHANCELLOR, QUEEN, ROOK, BISHOP, KNIGHT}; return v; } Variant* capahouse_variant() { Variant* v = capablanca_variant(); v->startFen = "rnabqkbcnr/pppppppppp/10/10/10/10/PPPPPPPPPP/RNABQKBCNR[] w KQkq - 0 1"; v->pieceDrops = true; v->capturesToHand = true; v->endgameEval = false; return v; } Variant* caparandom_variant() { Variant* v = capablanca_variant(); v->chess960 = true; return v; } Variant* gothic_variant() { Variant* v = capablanca_variant(); v->startFen = "rnbqckabnr/pppppppppp/10/10/10/10/PPPPPPPPPP/RNBQCKABNR w KQkq - 0 1"; return v; } Variant* janus_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBRQ............J...Kpnbrq............J...k"; v->maxRank = RANK_8; v->maxFile = FILE_J; v->castlingKingsideFile = FILE_I; v->castlingQueensideFile = FILE_B; v->add_piece(ARCHBISHOP, 'j'); v->startFen = "rjnbkqbnjr/pppppppppp/10/10/10/10/PPPPPPPPPP/RJNBKQBNJR w KQkq - 0 1"; v->promotionPieceTypes = {ARCHBISHOP, QUEEN, ROOK, BISHOP, KNIGHT}; return v; } Variant* modern_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBRQ..M.............Kpnbrq..m.............k"; v->maxRank = RANK_9; v->maxFile = FILE_I; v->promotionRank = RANK_9; v->castlingKingsideFile = FILE_G; v->castlingQueensideFile = FILE_C; v->add_piece(ARCHBISHOP, 'm'); v->startFen = "rnbqkmbnr/ppppppppp/9/9/9/9/9/PPPPPPPPP/RNBMKQBNR w KQkq - 0 1"; v->promotionPieceTypes = {ARCHBISHOP, QUEEN, ROOK, BISHOP, KNIGHT}; return v; } Variant* chancellor_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBRQ...........CKpnbrq...........ck"; v->maxRank = RANK_9; v->maxFile = FILE_I; v->promotionRank = RANK_9; v->castlingKingsideFile = FILE_G; v->castlingQueensideFile = FILE_C; v->add_piece(CHANCELLOR, 'c'); v->startFen = "rnbqkcnbr/ppppppppp/9/9/9/9/9/PPPPPPPPP/RNBQKCNBR w KQkq - 0 1"; v->promotionPieceTypes = {CHANCELLOR, QUEEN, ROOK, BISHOP, KNIGHT}; return v; } Variant* embassy_variant() { Variant* v = capablanca_variant(); v->castlingKingsideFile = FILE_H; v->castlingQueensideFile = FILE_B; v->startFen = "rnbqkcabnr/pppppppppp/10/10/10/10/PPPPPPPPPP/RNBQKCABNR w KQkq - 0 1"; return v; } Variant* centaur_variant() { Variant* v = chess_variant(); v->pieceToCharTable = "PNBRQ...............CKpnbrq...............ck"; v->maxRank = RANK_8; v->maxFile = FILE_J; v->castlingKingsideFile = FILE_I; v->castlingQueensideFile = FILE_C; v->add_piece(CENTAUR, 'c'); v->startFen = "rcnbqkbncr/pppppppppp/10/10/10/10/PPPPPPPPPP/RCNBQKBNCR w KQkq - 0 1"; v->promotionPieceTypes = {CENTAUR, QUEEN, ROOK, BISHOP, KNIGHT}; return v; } Variant* jesonmor_variant() { Variant* v = fairy_variant_base(); v->maxRank = RANK_9; v->maxFile = FILE_I; v->reset_pieces(); v->add_piece(KNIGHT, 'n'); v->startFen = "nnnnnnnnn/9/9/9/9/9/9/9/NNNNNNNNN w - - 0 1"; v->promotionPieceTypes = {}; v->doubleStep = false; v->castling = false; v->stalemateValue = -VALUE_MATE; v->flagPiece = KNIGHT; v->whiteFlag = make_bitboard(SQ_E5); v->blackFlag = make_bitboard(SQ_E5); v->flagMove = true; return v; } Variant* courier_variant() { Variant* v = fairy_variant_base(); v->maxRank = RANK_8; v->maxFile = FILE_L; v->remove_piece(QUEEN); v->add_piece(ALFIL, 'e'); v->add_piece(FERS, 'f'); v->add_piece(COMMONER, 'm'); v->add_piece(WAZIR, 'w'); v->startFen = "rnebmk1wbenr/1ppppp1pppp1/6f5/p5p4p/P5P4P/6F5/1PPPPP1PPPP1/RNEBMK1WBENR w - - 0 1"; v->promotionPieceTypes = {FERS}; v->doubleStep = false; v->castling = false; v->extinctionValue = -VALUE_MATE; v->extinctionClaim = true; v->extinctionPieceTypes = {ALL_PIECES}; v->extinctionPieceCount = 1; v->extinctionOpponentPieceCount = 2; v->stalemateValue = -VALUE_MATE; return v; } Variant* grand_variant() { Variant* v = fairy_variant_base(); v->pieceToCharTable = "PNBRQ..AC............Kpnbrq..ac............k"; v->maxRank = RANK_10; v->maxFile = FILE_J; v->add_piece(ARCHBISHOP, 'a'); v->add_piece(CHANCELLOR, 'c'); v->startFen = "r8r/1nbqkcabn1/pppppppppp/10/10/10/10/PPPPPPPPPP/1NBQKCABN1/R8R w - - 0 1"; v->promotionPieceTypes = {ARCHBISHOP, CHANCELLOR, QUEEN, ROOK, BISHOP, KNIGHT}; v->promotionRank = RANK_8; v->promotionLimit[ARCHBISHOP] = 1; v->promotionLimit[CHANCELLOR] = 1; v->promotionLimit[QUEEN] = 1; v->promotionLimit[ROOK] = 2; v->promotionLimit[BISHOP] = 2; v->promotionLimit[KNIGHT] = 2; v->mandatoryPawnPromotion = false; v->immobilityIllegal = true; v->doubleStepRank = RANK_3; v->castling = false; return v; } Variant* shako_variant() { Variant* v = fairy_variant_base(); v->pieceToCharTable = "PNBRQ.E....C.........Kpnbrq.e....c.........k"; v->maxRank = RANK_10; v->maxFile = FILE_J; v->add_piece(FERS_ALFIL, 'e'); v->add_piece(CANNON, 'c'); v->startFen = "c8c/ernbqkbnre/pppppppppp/10/10/10/10/PPPPPPPPPP/ERNBQKBNRE/C8C w KQkq - 0 1"; v->promotionPieceTypes = { QUEEN, ROOK, BISHOP, KNIGHT, CANNON, FERS_ALFIL }; v->promotionRank = RANK_10; v->castlingKingsideFile = FILE_H; v->castlingQueensideFile = FILE_D; v->castlingRank = RANK_2; v->doubleStepRank = RANK_3; return v; } Variant* clobber10_variant() { Variant* v = clobber_variant(); v->maxRank = RANK_10; v->maxFile = FILE_J; v->startFen = "PpPpPpPpPp/pPpPpPpPpP/PpPpPpPpPp/pPpPpPpPpP/PpPpPpPpPp/" "pPpPpPpPpP/PpPpPpPpPp/pPpPpPpPpP/PpPpPpPpPp/pPpPpPpPpP w 0 1"; return v; } Variant* xiangqi_variant() { Variant* v = minixiangqi_variant(); v->pieceToCharTable = "PN.R.AB..K.C..........pn.r.ab..k.c.........."; v->maxRank = RANK_10; v->maxFile = FILE_I; v->add_piece(ELEPHANT, 'b', 'e'); v->add_piece(FERS, 'a'); v->startFen = "rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR w - - 0 1"; Bitboard white_castle = make_bitboard(SQ_D1, SQ_E1, SQ_F1, SQ_D2, SQ_E2, SQ_F2, SQ_D3, SQ_E3, SQ_F3); Bitboard black_castle = make_bitboard(SQ_D8, SQ_E8, SQ_F8, SQ_D9, SQ_E9, SQ_F9, SQ_D10, SQ_E10, SQ_F10); v->mobilityRegion[WHITE][KING] = white_castle; v->mobilityRegion[BLACK][KING] = black_castle; v->mobilityRegion[WHITE][FERS] = white_castle; v->mobilityRegion[BLACK][FERS] = black_castle; v->mobilityRegion[WHITE][ELEPHANT] = Rank1BB | Rank2BB | Rank3BB | Rank4BB | Rank5BB; v->mobilityRegion[BLACK][ELEPHANT] = Rank6BB | Rank7BB | Rank8BB | Rank9BB | Rank10BB; v->soldierPromotionRank = RANK_6; return v; } // Manchu/Yitong chess // https://en.wikipedia.org/wiki/Manchu_chess Variant* manchu_variant() { Variant* v = xiangqi_variant(); v->pieceToCharTable = "PN.R.AB..K.C....M.....pn.r.ab..k.c.........."; v->add_piece(BANNER, 'm'); v->startFen = "rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/9/9/M1BAKAB2 w - - 0 1"; return v; } // Supply chess // https://en.wikipedia.org/wiki/Xiangqi#Variations Variant* supply_variant() { Variant* v = xiangqi_variant(); v->variantTemplate = "bughouse"; v->startFen = "rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR[] w - - 0 1"; v->twoBoards = true; v->pieceDrops = true; v->dropChecks = false; v->whiteDropRegion = v->mobilityRegion[WHITE][ELEPHANT]; v->blackDropRegion = v->mobilityRegion[BLACK][ELEPHANT]; return v; } // Janggi (Korean chess) // https://en.wikipedia.org/wiki/Janggi // Official tournament rules with bikjang and material counting. Variant* janggi_variant() { Variant* v = xiangqi_variant(); v->pieceToCharTable = ".N.R.AB.P..C.........K.n.r.ab.p..c.........k"; v->remove_piece(FERS); v->remove_piece(CANNON); v->remove_piece(ELEPHANT); v->add_piece(WAZIR, 'a'); v->add_piece(JANGGI_CANNON, 'c'); v->add_piece(JANGGI_ELEPHANT, 'b', 'e'); v->startFen = "rnba1abnr/4k4/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/4K4/RNBA1ABNR w - - 0 1"; Bitboard white_castle = make_bitboard(SQ_D1, SQ_E1, SQ_F1, SQ_D2, SQ_E2, SQ_F2, SQ_D3, SQ_E3, SQ_F3); Bitboard black_castle = make_bitboard(SQ_D8, SQ_E8, SQ_F8, SQ_D9, SQ_E9, SQ_F9, SQ_D10, SQ_E10, SQ_F10); v->mobilityRegion[WHITE][WAZIR] = white_castle; v->mobilityRegion[BLACK][WAZIR] = black_castle; v->soldierPromotionRank = RANK_1; v->flyingGeneral = false; v->bikjangRule = true; v->materialCounting = JANGGI_MATERIAL; v->diagonalLines = make_bitboard(SQ_D1, SQ_F1, SQ_E2, SQ_D3, SQ_F3, SQ_D8, SQ_F8, SQ_E9, SQ_D10, SQ_F10); v->kingPass = true; v->nFoldValue = VALUE_DRAW; v->perpetualCheckIllegal = true; return v; } // Traditional rules of Janggi, where bikjang is a draw Variant* janggi_traditional_variant() { Variant* v = janggi_variant(); v->bikjangRule = true; v->materialCounting = NO_MATERIAL_COUNTING; return v; } // Modern rules of Janggi, where bikjang is not considered, but material counting is. // This is e.g. used on Kakao Janggi. Variant* janggi_modern_variant() { Variant* v = janggi_variant(); v->bikjangRule = false; v->materialCounting = JANGGI_MATERIAL; return v; } // Casual rules of Janggi, where bikjang and material counting are not considered Variant* janggi_casual_variant() { Variant* v = janggi_variant(); v->bikjangRule = false; v->materialCounting = NO_MATERIAL_COUNTING; return v; } #endif } // namespace /// VariantMap::init() is called at startup to initialize all predefined variants void VariantMap::init() { // Add to UCI_Variant option add("chess", chess_variant()); add("normal", chess_variant()); add("fischerandom", chess960_variant()); add("nocastle", nocastle_variant()); add("fairy", fairy_variant()); // fairy variant used for endgame code initialization add("makruk", makruk_variant()); add("makpong", makpong_variant()); add("cambodian", cambodian_variant()); add("karouk", karouk_variant()); add("asean", asean_variant()); add("ai-wok", aiwok_variant()); add("shatranj", shatranj_variant()); add("amazon", amazon_variant()); add("hoppelpoppel", hoppelpoppel_variant()); add("newzealand", newzealand_variant()); add("kingofthehill", kingofthehill_variant()); add("racingkings", racingkings_variant()); add("knightmate", knightmate_variant()); add("losers", losers_variant()); add("giveaway", giveaway_variant()); add("antichess", antichess_variant()); add("suicide", suicide_variant()); add("codrus", codrus_variant()); add("extinction", extinction_variant()); add("kinglet", kinglet_variant()); add("threekings", threekings_variant()); add("horde", horde_variant()); add("3check", threecheck_variant()); add("5check", fivecheck_variant()); add("crazyhouse", crazyhouse_variant()); add("loop", loop_variant()); add("chessgi", chessgi_variant()); add("bughouse", bughouse_variant()); add("koedem", koedem_variant()); add("pocketknight", pocketknight_variant()); add("placement", placement_variant()); add("sittuyin", sittuyin_variant()); add("seirawan", seirawan_variant()); add("shouse", shouse_variant()); add("minishogi", minishogi_variant()); add("mini", minishogi_variant()); add("kyotoshogi", kyotoshogi_variant()); add("micro", microshogi_variant()); add("dobutsu", dobutsu_variant()); add("gorogoro", gorogoroshogi_variant()); add("judkins", judkinsshogi_variant()); add("euroshogi", euroshogi_variant()); add("losalamos", losalamos_variant()); add("gardner", gardner_variant()); add("almost", almost_variant()); add("chigorin", chigorin_variant()); add("shatar", shatar_variant()); add("clobber", clobber_variant()); add("breakthrough", breakthrough_variant()); add("minixiangqi", minixiangqi_variant()); #ifdef LARGEBOARDS add("shogi", shogi_variant()); add("capablanca", capablanca_variant()); add("capahouse", capahouse_variant()); add("caparandom", caparandom_variant()); add("gothic", gothic_variant()); add("janus", janus_variant()); add("modern", modern_variant()); add("chancellor", chancellor_variant()); add("embassy", embassy_variant()); add("centaur", centaur_variant()); add("jesonmor", jesonmor_variant()); add("courier", courier_variant()); add("grand", grand_variant()); add("shako", shako_variant()); add("clobber10", clobber10_variant()); add("xiangqi", xiangqi_variant()); add("manchu", manchu_variant()); add("supply", supply_variant()); add("janggi", janggi_variant()); add("janggitraditional", janggi_traditional_variant()); add("janggimodern", janggi_modern_variant()); add("janggicasual", janggi_casual_variant()); #endif } /// VariantMap::parse reads variants from an INI-style configuration file. template void VariantMap::parse(std::string path) { if (path.empty() || path == "") return; std::ifstream file(path); if (!file.is_open()) { std::cerr << "Unable to open file " << path << std::endl; return; } std::string variant, variant_template, key, value, input; while (file.peek() != '[' && std::getline(file, input)) {} std::vector varsToErase = {}; while (file.get() && std::getline(std::getline(file, variant, ']'), input)) { // Extract variant template, if specified if (!std::getline(std::getline(std::stringstream(variant), variant, ':'), variant_template)) variant_template = ""; // Read variant rules Config attribs = {}; while (file.peek() != '[' && std::getline(file, input)) { std::stringstream ss(input); if (ss.peek() != '#' && std::getline(std::getline(ss, key, '=') >> std::ws, value) && !key.empty()) attribs[key.erase(key.find_last_not_of(" ") + 1)] = value; } // Create variant if (variants.find(variant) != variants.end()) std::cerr << "Variant '" << variant << "' already exists." << std::endl; else if (!variant_template.empty() && variants.find(variant_template) == variants.end()) std::cerr << "Variant template '" << variant_template << "' does not exist." << std::endl; else { if (DoCheck) std::cerr << "Parsing variant: " << variant << std::endl; Variant* v = !variant_template.empty() ? VariantParser(attribs).parse(new Variant(*variants.find(variant_template)->second)) : VariantParser(attribs).parse(); if (v->maxFile <= FILE_MAX && v->maxRank <= RANK_MAX) { add(variant, v); // In order to allow inheritance, we need to temporarily add configured variants // even when only checking them, but we remove them later after parsing is finished. if (DoCheck) varsToErase.push_back(variant); } else delete v; } } file.close(); // Clean up temporary variants for (std::string tempVar : varsToErase) { delete variants[tempVar]; variants.erase(tempVar); } } template void VariantMap::parse(std::string path); template void VariantMap::parse(std::string path); void VariantMap::add(std::string s, const Variant* v) { insert(std::pair(s, v)); } void VariantMap::clear_all() { for (auto const& element : *this) delete element.second; clear(); } std::vector VariantMap::get_keys() { std::vector keys; for (auto const& element : *this) keys.push_back(element.first); return keys; } Fairy-Stockfish-fairy_sf_11_1/src/variant.h000066400000000000000000000124561366242550200210250ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #ifndef VARIANT_H_INCLUDED #define VARIANT_H_INCLUDED #include #include #include #include #include #include "types.h" #include "bitboard.h" /// Variant struct stores information needed to determine the rules of a variant. struct Variant { std::string variantTemplate = "fairy"; std::string pieceToCharTable = "-"; int pocketSize = 0; Rank maxRank = RANK_8; File maxFile = FILE_H; bool chess960 = false; bool twoBoards = false; std::set pieceTypes = { PAWN, KNIGHT, BISHOP, ROOK, QUEEN, KING }; std::string pieceToChar = " PNBRQ" + std::string(KING - QUEEN - 1, ' ') + "K" + std::string(PIECE_TYPE_NB - KING - 1, ' ') + " pnbrq" + std::string(KING - QUEEN - 1, ' ') + "k" + std::string(PIECE_TYPE_NB - KING - 1, ' '); std::string pieceToCharSynonyms = std::string(PIECE_NB, ' '); std::string startFen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"; Bitboard mobilityRegion[COLOR_NB][PIECE_TYPE_NB] = {}; Rank promotionRank = RANK_8; std::set > promotionPieceTypes = { QUEEN, ROOK, BISHOP, KNIGHT }; bool sittuyinPromotion = false; int promotionLimit[PIECE_TYPE_NB] = {}; // 0 means unlimited PieceType promotedPieceType[PIECE_TYPE_NB] = {}; bool piecePromotionOnCapture = false; bool mandatoryPawnPromotion = true; bool mandatoryPiecePromotion = false; bool pieceDemotion = false; bool endgameEval = false; bool doubleStep = true; Rank doubleStepRank = RANK_2; bool firstRankDoubleSteps = false; bool castling = true; bool castlingDroppedPiece = false; File castlingKingsideFile = FILE_G; File castlingQueensideFile = FILE_C; Rank castlingRank = RANK_1; PieceType castlingRookPiece = ROOK; PieceType kingType = KING; bool checking = true; bool dropChecks = true; bool mustCapture = false; bool mustDrop = false; PieceType mustDropType = ALL_PIECES; bool pieceDrops = false; bool dropLoop = false; bool capturesToHand = false; bool firstRankPawnDrops = false; bool promotionZonePawnDrops = false; bool dropOnTop = false; Bitboard whiteDropRegion = AllSquares; Bitboard blackDropRegion = AllSquares; bool sittuyinRookDrop = false; bool dropOppositeColoredBishop = false; bool dropPromoted = false; bool shogiDoubledPawn = true; bool immobilityIllegal = false; bool gating = false; bool seirawanGating = false; bool cambodianMoves = false; Bitboard diagonalLines = 0; bool kingPass = false; bool kingPassOnStalemate = false; bool makpongRule = false; bool flyingGeneral = false; Rank soldierPromotionRank = RANK_1; // game end int nMoveRule = 50; int nFoldRule = 3; Value nFoldValue = VALUE_DRAW; bool nFoldValueAbsolute = false; bool perpetualCheckIllegal = false; Value stalemateValue = VALUE_DRAW; bool stalematePieceCount = false; // multiply stalemate value by sign(count(~stm) - count(stm)) Value checkmateValue = -VALUE_MATE; bool shogiPawnDropMateIllegal = false; bool shatarMateRule = false; bool bikjangRule = false; Value extinctionValue = VALUE_NONE; bool extinctionClaim = false; std::set extinctionPieceTypes = {}; int extinctionPieceCount = 0; int extinctionOpponentPieceCount = 0; PieceType flagPiece = NO_PIECE_TYPE; Bitboard whiteFlag = 0; Bitboard blackFlag = 0; bool flagMove = false; bool checkCounting = false; int connectN = 0; MaterialCounting materialCounting = NO_MATERIAL_COUNTING; CountingRule countingRule = NO_COUNTING; void add_piece(PieceType pt, char c, char c2 = ' ') { pieceToChar[make_piece(WHITE, pt)] = toupper(c); pieceToChar[make_piece(BLACK, pt)] = tolower(c); pieceToCharSynonyms[make_piece(WHITE, pt)] = toupper(c2); pieceToCharSynonyms[make_piece(BLACK, pt)] = tolower(c2); pieceTypes.insert(pt); } void remove_piece(PieceType pt) { pieceToChar[make_piece(WHITE, pt)] = ' '; pieceToChar[make_piece(BLACK, pt)] = ' '; pieceToCharSynonyms[make_piece(WHITE, pt)] = ' '; pieceToCharSynonyms[make_piece(BLACK, pt)] = ' '; pieceTypes.erase(pt); } void reset_pieces() { pieceToChar = std::string(PIECE_NB, ' '); pieceToCharSynonyms = std::string(PIECE_NB, ' '); pieceTypes.clear(); } }; class VariantMap : public std::map { public: void init(); template void parse(std::string path); void clear_all(); std::vector get_keys(); private: void add(std::string s, const Variant* v); }; extern VariantMap variants; #endif // #ifndef VARIANT_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/src/variants.ini000066400000000000000000000337211366242550200215360ustar00rootroot00000000000000# Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish # Copyright (C) 2018-2020 Fabian Fichter # # Fairy-Stockfish 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. # # Fairy-Stockfish 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 . # This is a configuration file to add user-defined variants to Fairy-Stockfish. ################################################ ### Usage: # Add "load" and the file path to the SF call (e.g., "./stockfish load variants.ini") # or set the UCI option "VariantPath" to the path of this file in order to load it. # In order to validate the configuration without actually loading the variants # run "./stockfish check variants.ini", which reports potential config errors. ################################################ ### Variant configuration: # The variant name needs to be specified as a section in square brackets, # followed by its rule configurations as key-value pairs as described below. # If you encounter problems configuring variants, please report them at: # https://github.com/ianfab/Fairy-Stockfish/issues ### Inheritance # If a variant is similar to a previously defined variant, # inheritance can be used to simplify the definition. To inherit from the # configuration of an existing variant, specify the parent variant after the child # variant name separated by a colon, e.g., [gothic:capablanca]. # When inheritance is used, only the differences to the parent variant need to be defined, # see the examples in this file, e.g., 3check-crazyhouse. # When no inheritance is used, the default template applies, # which is basically standard chess but without any predefined pieces. ### Piece types # Firstly, the piece types for a variant need to be defined. # For that, specify the letter used for each piece type, e.g.: # pawn = p # # See the list below for all available piece types: # pawn # knight # bishop # rook # queen # fers # alfil # fersAlfil (=fers+alfil) # silver # aiwok (=rook+knight+fers) # bers (=rook+fers) # archbishop (=bishop+knight) # chancellor (=rook+knight) # amazon (=queen+knight) # knibis # biskni # kniroo # rookni # shogiPawn # lance # shogiKnight # euroshogiKnight # gold # dragonHorse # clobber # breakthrough # immobile (piece without moves) # cannon # janggiCannon # soldier # horse # elephant # janggiElephant # banner (=rook+cannon+horse) # wazir # commoner (non-royal king) # centaur (=knight+commoner) # king ### Option types # [bool]: boolean flag to enable/disable a feature [true, false] # [Rank]: denotes a rank of the board [1-10] # [File]: denotes a file of the board [1-12, a-i] # [int]: any natural number [0, 1, ...] # [PieceType]: a piece type [letters defined for pieces, e.g., p] # [Bitboard]: list of squares [e.g., d4 e4 d5 e5]. * can be used as wildcard for files (e.g., *1 is the first rank) # [Value]: game result for the side to move [win, loss, draw] # [MaterialCounting]: material couting rules for adjudication [janggi, unweighted, none] # [CountingRule]: makruk or ASEAN counting rules [makruk, asean, none] ### Rule definition options # variantTemplate: only relevant for usage in XBoard/WinBoard GUI [values: fairy, shogi] (default: fairy) # pieceToCharTable: mapping of piece characters to images for XBoard/WinBoard GUI (default: -) # pocketSize: number of pockets shown by XBoard/WinBoard for drop variants [int] (default: 0) # maxRank: maximum rank [Rank] (default: 8) # maxFile: maximum file [File] (default: 8) # chess960: allow chess960 castling [bool] (default: false) # twoBoards: the game is influenced by a second board (e.g., bughouse) [bool] (default: false) # startFen: FEN of starting position (default: rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1) # mobilityRegion: the mobility area can be defined via options specific to color and piece, # .e.g., mobilityRegionWhiteRook, mobilityRegionBlackJanggiElephant, etc. [Bitboard] # promotionRank: relative rank required to reach for promotion [Rank] (default: 8) # promotionPieceTypes: pawn promotion options using their one-letter representations (default: nbrq) # sittuyinPromotion: enable Sittuyin-style pawn promotion [bool] (default: false) # promotionLimit: maximum number of pieces of a type, e.g., q:1 r:2 (default: ) # promotedPieceType: mapping between unpromoted and promoted non-pawn piece types, e.g., p:g s:g (default: ) # piecePromotionOnCapture: piece promotion only allowed on captures (e.g., micro shogi) [bool] (default: false) # mandatoryPawnPromotion: pawn promotion is mandatory [bool] (default: true) # mandatoryPiecePromotion: piece promotion (and demotion if enabled) is mandatory [bool] (default: false) # pieceDemotion: enable demotion of pieces (e.g., Kyoto shogi) [bool] (default: false) # endgameEval: enable special endgame evaluation (for very chess-like variants only) [bool] (default: false) # doubleStep: enable pawn double step [bool] (default: true) # doubleStepRank: relative rank from where pawn double steps are allowed [Rank] (default: 2) # firstRankDoubleSteps: enable pawn double steps from first rank [bool] (default: false) # castling: enable castling [bool] (default: true) # castlingDroppedPiece: enable castling with dropped rooks/kings [bool] (default: false) # castlingKingsideFile: destination file of king after kingside castling [File] (default: g) # castlingQueensideFile: destination file of king after queenside castling [File] (default: c) # castlingRank: relative rank of castling [Rank] (default: 1) # castlingRookPiece: piece type that participates in castling [PieceType] (default: r) # kingType: piece type defining moves of king/royal piece (default: k) # checking: allow checks [bool] (default: true) # dropChecks: allow checks by piece drops [bool] (default: true) # mustCapture: captures are mandatory (check evasion still takes precedence) [bool] (default: false) # mustDrop: drops are mandatory (e.g., for Sittuyin setup phase) [bool] (default: false) # mustDropType: piece type for which piece drops are mandatory [PieceType] (default: *) # pieceDrops: enable piece drops [bool] (default: false) # dropLoop: captures promoted pieces are not demoted [bool] (default: false) # capturesToHand: captured pieces are go to opponent's hand [bool] (default: false) # firstRankPawnDrops: allow pawn drops to first rank [bool] (default: false) # promotionZonePawnDrops: allow pawn drops in promotion zone [bool] (default: false) # dropOnTop: piece drops need to be on top of pieces on board (e.g., for connect4) [bool] (default: false) # whiteDropRegion: restrict region for piece drops of all white pieces [Bitboard] # blackDropRegion: restrict region for piece drops of all black pieces [Bitboard] # sittuyinRookDrop: restrict region of rook drops to first rank [bool] (default: false) # dropOppositeColoredBishop: dropped bishops have to be on opposite-colored squares [bool] (default: false) # dropPromoted: pieces may be dropped in promoted state [bool] (default: false) # shogiDoubledPawn: allow shogi pawns to be doubled [bool] (default: true) # immobilityIllegal: pieces may not move to squares where they can never move from [bool] (default: false) # gating: maintain squares on backrank with extra rights in castling field of FEN [bool] (default: false) # seirawanGating: allow gating of pieces in hand like in S-Chess, requires "gating = true" [bool] (default: false) # cambodianMoves: enable special moves of cambodian chess, requires "gating = true" [bool] (default: false) # diagonalLines: enable special moves along diagonal for specific squares (Janggi) [Bitboard] # kingPass: allow passing by king [bool] (default: false) # kingPassOnStalemate: allow passing by king in case of stalemate [bool] (default: false) # makpongRule: the king may not move away from check [bool] (default: false) # flyingGeneral: disallow general face-off like in xiangqi [bool] (default: false) # soldierPromotionRank: restrict soldier to shogi pawn movements until reaching n-th rank [bool] (default: 1) # nMoveRule: move count for 50/n-move rule [int] (default: 50) # nFoldRule: move count for 3/n-fold repetition rule [int] (default: 3) # nFoldValue: result in case of 3/n-fold repetition [Value] (default: draw) # nFoldValueAbsolute: result in case of 3/n-fold repetition is from white's point of view [bool] (default: false) # perpetualCheckIllegal: prohibit perpetual checks [bool] (default: false) # stalemateValue: result in case of stalemate [Value] (default: draw) # checkmateValue: result in case of checkmate [Value] (default: loss) # shogiPawnDropMateIllegal: prohibit checkmate via shogi pawn drops [bool] (default: false) # shatarMateRule: enable shatar mating rules [bool] (default: false) # bikjangRule: consider Janggi bikjang (facing kings) rule [bool] (default: false) # extinctionValue: result when one of extinctionPieceTypes is extinct [Value] (default: none) # extinctionClaim: extinction of opponent pieces can only be claimed as side to move [bool] (default: false) # extinctionPieceTypes: list of piece types for extinction rules, e.g., pnbrq (* means all) (default: ) # extinctionPieceCount: piece count at which the game is decided by extinction rule (default: 0) # extinctionOpponentPieceCount: opponent piece count required to adjudicate by extinction rule (default: 0) # flagPiece: piece type for capture the flag win rule [PieceType] (default: -) # whiteFlag: white's target region for capture the flag win rule [Bitboard] (default: ) # blackFlag: black's target region for capture the flag win rule [Bitboard] (default: ) # flagMove: black gets one more move after white captures the flag [bool] (default: false) # checkCounting: enable check count win rule (check count is communicated via FEN, see 3check) [bool] (default: false) # connectN: number of aligned pieces for win [int] (default: 0) # materialCounting: enable material counting rules [MaterialCounting] (default: none) # countingRule: enable counting rules [CountingRule] (default: none) ################################################ ### Example for minishogi configuration that would be equivalent to the built-in variant: # [minishogi] # variantTemplate = shogi # maxRank = 5 # maxFile = 5 # shogiPawn = p # silver = s # gold = g # bishop = b # dragonHorse = h # rook = r # bers = d # king = k # startFen = rbsgk/4p/5/P4/KGSBR[-] w 0 1 # pieceDrops = true # capturesToHand = true # promotionRank = 5 # doubleStep = false # castling = false # promotedPieceType = p:g s:g b:h r:d # shogiDoubledPawn = false # immobilityIllegal = true # shogiPawnDropMateIllegal = true # stalemateValue = loss # nFoldRule = 4 # nMoveRule = 0 # perpetualCheckIllegal = true # pocketSize = 5 # nFoldValue = loss # nFoldValueAbsolute = true # Hybrid variant of three-check chess and crazyhouse, using crazyhouse as a template [3check-crazyhouse:crazyhouse] startFen = rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR[] w KQkq - 3+3 0 1 checkCounting = true # Crazyhouse with mandatory captures, using crazyhouse as a template [coffeehouse:crazyhouse] mustCapture = true # Hybrid variant of makruk and crazyhouse [makrukhouse:makruk] pieceDrops = true capturesToHand = true # Hybrid variant of xiangqi and crazyhouse [xiangqihouse:xiangqi] pieceDrops = true capturesToHand = true dropChecks = false whiteDropRegion = *1 *2 *3 *4 *5 blackDropRegion = *6 *7 *8 *9 *10 # Hybrid variant of janggi and crazyhouse [janggihouse:janggi] pieceDrops = true capturesToHand = true # Hybrid variant of antichess and losalamos [anti-losalamos:losalamos] king = - commoner = k promotionPieceTypes = nrqk mustCapture = true stalemateValue = win extinctionValue = win extinctionPieceTypes = * # Indian great chess # https://www.chessvariants.com/historic.dir/indiangr1.html [indiangreat] pieceToCharTable = PNBRQ..VW.........G..Kpnbrq..vw.........g..k pawn = p knight = n bishop = b rook = r queen = q king = k archbishop = v chancellor = w amazon = g maxRank = 10 maxFile = 10 startFen = rnbqkgvbnr/ppppwwpppp/4pp4/10/10/10/10/4PP4/PPPPWWPPPP/RNBVGKQBNR w - - 0 1 promotionRank = 10 promotionPieceTypes = q doubleStep = false castling = false # Peasant revolt # https://www.chessvariants.com/large.dir/peasantrevolt.html [peasant:chess] startFen = 1nn1k1n1/4p3/8/8/8/8/PPPPPPPP/4K3 w - - 0 1 [tictactoe] maxRank = 3 maxFile = 3 immobile = p startFen = 3/3/3[PPPPPpppp] w - - 0 1 pieceDrops = true doubleStep = false castling = false stalemateValue = draw immobilityIllegal = false connectN = 3 [connect4] maxRank = 6 maxFile = 7 immobile = p startFen = 7/7/7/7/7/7[PPPPPPPPPPPPPPPPPPPPPppppppppppppppppppppp] w - - 0 1 pieceDrops = true dropOnTop = true doubleStep = false castling = false stalemateValue = draw immobilityIllegal = false connectN = 4 nMoveRule = 0 [grandhouse:grand] startFen = r8r/1nbqkcabn1/pppppppppp/10/10/10/10/PPPPPPPPPP/1NBQKCABN1/R8R[] w - - 0 1 pieceDrops = true capturesToHand = true [shogun:crazyhouse] variantTemplate = shogi pieceToCharTable = PNBR.F.....++++.+Kpnbr.f.....++++.+k pocketSize = 8 startFen = rnb+fkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB+FKBNR w KQkq - 0 1 commoner = c centaur = g archbishop = a chancellor = m fers = f promotionRank = 6 promotionLimit = g:1 a:1 m:1 q:1 promotionPieceTypes = - promotedPieceType = p:c n:g b:a r:m f:q mandatoryPawnPromotion = false firstRankPawnDrops = true promotionZonePawnDrops = true whiteDropRegion = *1 *2 *3 *4 *5 blackDropRegion = *4 *5 *6 *7 *8 immobilityIllegal = true # Asymmetric variant with one army using pieces that move like knights but attack like other pieces (kniroo and knibis) [orda:chess] pieceToCharTable = PNBRQ..AH...........LKp...q..ah.y.........lk centaur = h knibis = a kniroo = l silver = y promotionPieceTypes = qh startFen = lhaykahl/8/pppppppp/8/8/8/PPPPPPPP/RNBQKBNR w KQ - 0 1 flagPiece = k whiteFlag = *8 blackFlag = *1 Fairy-Stockfish-fairy_sf_11_1/src/xboard.cpp000066400000000000000000000301541366242550200211660ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #include #include #include "evaluate.h" #include "partner.h" #include "search.h" #include "thread.h" #include "types.h" #include "uci.h" #include "xboard.h" namespace { const Search::LimitsType analysisLimits = []{ Search::LimitsType limits; limits.infinite = 1; return limits; }(); // go() starts the search for game play, analysis, or perft. void go(Position& pos, Search::LimitsType limits, StateListPtr& states) { limits.startTime = now(); // As early as possible! Threads.start_thinking(pos, states, limits, false); } // setboard() is called when engine receives the "setboard" XBoard command. void setboard(Position& pos, StateListPtr& states, std::string fen = "") { if (fen.empty()) fen = variants.find(Options["UCI_Variant"])->second->startFen; states = StateListPtr(new std::deque(1)); // Drop old and create a new one pos.set(variants.find(Options["UCI_Variant"])->second, fen, Options["UCI_Chess960"], &states->back(), Threads.main()); } // do_move() is called when engine needs to apply a move when using XBoard protocol. void do_move(Position& pos, std::deque& moveList, StateListPtr& states, Move m) { // transfer states back if (Threads.setupStates.get()) states = std::move(Threads.setupStates); if (m == MOVE_NONE) return; moveList.push_back(m); states->emplace_back(); pos.do_move(m, states->back()); } // undo_move() is called when the engine receives the undo command in XBoard protocol. void undo_move(Position& pos, std::deque& moveList, StateListPtr& states) { // transfer states back if (Threads.setupStates.get()) states = std::move(Threads.setupStates); pos.undo_move(moveList.back()); states->pop_back(); moveList.pop_back(); } } // namespace namespace XBoard { /// StateMachine::process_command() processes commands of the XBoard protocol. void StateMachine::process_command(Position& pos, std::string token, std::istringstream& is, StateListPtr& states) { if (moveAfterSearch && token != "ptell") { // abort search in bughouse when receiving "holding" command bool doMove = token != "holding" || Threads.abort.exchange(true); Threads.stop = true; Threads.main()->wait_for_search_finished(); if (doMove) { do_move(pos, moveList, states, Threads.main()->bestThread->rootMoves[0].pv[0]); moveAfterSearch = false; } } if (token == "protover") { std::string vars = "chess"; for (std::string v : variants.get_keys()) if (v != "chess") vars += "," + v; sync_cout << "feature setboard=1 usermove=1 time=1 memory=1 smp=1 colors=0 draw=0 " << "highlight=1 name=0 sigint=0 ping=1 myname=Fairy-Stockfish variants=\"" << vars << "\"" << Options << sync_endl; sync_cout << "feature done=1" << sync_endl; } else if (token == "accepted" || token == "rejected" || token == "result" || token == "?") {} else if (token == "hover" || token == "put") {} else if (token == "lift") { if (is >> token) { Bitboard promotions = 0, captures = 0, quiets = 0; // Collect targets for (const auto& m : MoveList(pos)) { Square from = from_sq(m), to = to_sq(m); if (is_ok(from) && UCI::square(pos, from) == token) { if (type_of(m) == PROMOTION) promotions |= to; else if (pos.capture(m)) captures |= to; else { if (type_of(m) == CASTLING && !pos.is_chess960()) to = make_square(to > from ? pos.castling_kingside_file() : pos.castling_queenside_file(), rank_of(from)); quiets |= to; } } } // Generate color FEN int emptyCnt; std::ostringstream ss; for (Rank r = pos.max_rank(); r >= RANK_1; --r) { for (File f = FILE_A; f <= pos.max_file(); ++f) { for (emptyCnt = 0; f <= pos.max_file() && !((promotions | captures | quiets) & make_square(f, r)); ++f) ++emptyCnt; if (emptyCnt) ss << emptyCnt; if (f <= pos.max_file()) ss << (promotions & make_square(f, r) ? "M" : captures & make_square(f, r) ? "R" : "Y"); } if (r > RANK_1) ss << '/'; } sync_cout << "highlight " << ss.str() << sync_endl; } } else if (token == "ping") { if (!(is >> token)) token = ""; sync_cout << "pong " << token << sync_endl; } else if (token == "new") { Search::clear(); setboard(pos, states); // play second by default playColor = ~pos.side_to_move(); Threads.sit = false; Partner.reset(); } else if (token == "variant") { if (is >> token) Options["UCI_Variant"] = token; setboard(pos, states); } else if (token == "force") playColor = COLOR_NB; else if (token == "go") { playColor = pos.side_to_move(); go(pos, limits, states); moveAfterSearch = true; } else if (token == "level" || token == "st" || token == "sd" || token == "time" || token == "otim") { int num; if (token == "level") { // moves to go is >> limits.movestogo; // base time is >> token; size_t idx = token.find(":"); if (idx != std::string::npos) num = std::stoi(token.substr(0, idx)) * 60 + std::stoi(token.substr(idx + 1)); else num = std::stoi(token) * 60; limits.time[WHITE] = num * 1000; limits.time[BLACK] = num * 1000; // increment is >> num; limits.inc[WHITE] = num * 1000; limits.inc[BLACK] = num * 1000; } else if (token == "sd") is >> limits.depth; else if (token == "st") { is >> num; limits.movetime = num * 1000; } // Note: time/otim are in centi-, not milliseconds else if (token == "time") { is >> num; limits.time[playColor != COLOR_NB ? playColor : pos.side_to_move()] = num * 10; } else if (token == "otim") { is >> num; limits.time[playColor != COLOR_NB ? ~playColor : ~pos.side_to_move()] = num * 10; } } else if (token == "setboard") { std::string fen; std::getline(is >> std::ws, fen); // Check if setboard actually indicates a passing move // to avoid unnecessarily clearing the move history if (pos.king_pass()) { StateInfo st; Position p; p.set(pos.variant(), fen, pos.is_chess960(), &st, pos.this_thread()); Move m; std::string passMove = "pass"; if ((m = UCI::to_move(pos, passMove)) != MOVE_NONE) do_move(pos, moveList, states, m); // apply setboard if passing does not lead to a match if (pos.key() != p.key()) setboard(pos, states, fen); } else setboard(pos, states, fen); // Winboard sends setboard after passing moves if (pos.side_to_move() == playColor) { go(pos, limits, states); moveAfterSearch = true; } } else if (token == "cores") { if (is >> token) Options["Threads"] = token; } else if (token == "memory") { if (is >> token) Options["Hash"] = token; } else if (token == "hard" || token == "easy") Options["Ponder"] = token == "hard"; else if (token == "option") { std::string name, value; is.get(); std::getline(is, name, '='); std::getline(is, value); if (Options.count(name)) { if (Options[name].get_type() == "check") value = value == "1" ? "true" : "false"; Options[name] = value; } } else if (token == "analyze") { Options["UCI_AnalyseMode"] = std::string("true"); go(pos, analysisLimits, states); } else if (token == "exit") { Threads.stop = true; Threads.main()->wait_for_search_finished(); Options["UCI_AnalyseMode"] = std::string("false"); } else if (token == "undo") { if (moveList.size()) { if (Options["UCI_AnalyseMode"]) { Threads.stop = true; Threads.main()->wait_for_search_finished(); } undo_move(pos, moveList, states); if (Options["UCI_AnalyseMode"]) go(pos, analysisLimits, states); } } // Bughouse commands else if (token == "partner") Partner.parse_partner(is); else if (token == "ptell") { Partner.parse_ptell(is, pos); // play move requested by partner if (moveAfterSearch && Partner.moveRequested) { Threads.stop = true; Threads.main()->wait_for_search_finished(); sync_cout << "move " << UCI::move(pos, Partner.moveRequested) << sync_endl; do_move(pos, moveList, states, Partner.moveRequested); moveAfterSearch = false; Partner.moveRequested = MOVE_NONE; } } else if (token == "holding") { // holding [] [] std::string white_holdings, black_holdings; if ( std::getline(is, token, '[') && std::getline(is, white_holdings, ']') && std::getline(is, token, '[') && std::getline(is, black_holdings, ']')) { std::string fen; char color, pieceType; // Use the obtained holding if available to avoid race conditions if (is >> color && is >> pieceType) { fen = pos.fen(); fen.insert(fen.find(']'), 1, toupper(color) == 'B' ? tolower(pieceType) : toupper(pieceType)); } else { std::transform(black_holdings.begin(), black_holdings.end(), black_holdings.begin(), ::tolower); fen = pos.fen(false, false, 0, white_holdings + black_holdings); } setboard(pos, states, fen); } // restart search if (moveAfterSearch) go(pos, limits, states); } // Additional custom non-XBoard commands else if (token == "perft") { Search::LimitsType perft_limits; is >> perft_limits.perft; go(pos, perft_limits, states); } else if (token == "d") sync_cout << pos << sync_endl; else if (token == "eval") sync_cout << Eval::trace(pos) << sync_endl; // Move strings and unknown commands else { // process move string if (token == "usermove") is >> token; if (Options["UCI_AnalyseMode"]) { Threads.stop = true; Threads.main()->wait_for_search_finished(); } Move m; if ((m = UCI::to_move(pos, token)) != MOVE_NONE) do_move(pos, moveList, states, m); else sync_cout << "Error (unkown command): " << token << sync_endl; if (Options["UCI_AnalyseMode"]) go(pos, analysisLimits, states); else if (pos.side_to_move() == playColor) { go(pos, limits, states); moveAfterSearch = true; } } } } // namespace XBoard Fairy-Stockfish-fairy_sf_11_1/src/xboard.h000066400000000000000000000025751366242550200206410ustar00rootroot00000000000000/* Fairy-Stockfish, a UCI chess variant playing engine derived from Stockfish Copyright (C) 2018-2020 Fabian Fichter Fairy-Stockfish 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. Fairy-Stockfish 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 . */ #ifndef XBOARD_H_INCLUDED #define XBOARD_H_INCLUDED #include #include #include "types.h" class Position; namespace XBoard { /// StateMachine class maintains the states required by XBoard protocol class StateMachine { public: StateMachine() { moveList = std::deque(); moveAfterSearch = false; playColor = COLOR_NB; } void process_command(Position& pos, std::string token, std::istringstream& is, StateListPtr& states); private: std::deque moveList; Search::LimitsType limits; bool moveAfterSearch; Color playColor; }; } // namespace XBoard #endif // #ifndef XBOARD_H_INCLUDED Fairy-Stockfish-fairy_sf_11_1/test.py000066400000000000000000000523511366242550200177500ustar00rootroot00000000000000# -*- coding: utf-8 -*- import faulthandler import unittest import pyffish as sf faulthandler.enable() CHESS = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1" CHESS960 = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w HAha - 0 1" CAPA = "rnabqkbcnr/pppppppppp/10/10/10/10/PPPPPPPPPP/RNABQKBCNR w KQkq - 0 1" CAPAHOUSE = "rnabqkbcnr/pppppppppp/10/10/10/10/PPPPPPPPPP/RNABQKBCNR[] w KQkq - 0 1" SITTUYIN = "8/8/4pppp/pppp4/4PPPP/PPPP4/8/8[KFRRSSNNkfrrssnn] w - - 0 1" MAKRUK = "rnsmksnr/8/pppppppp/8/8/PPPPPPPP/8/RNSKMSNR w - - 0 1" SHOGI = "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL[-] w - - 0 1" SHOGI_SFEN = "lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL b - 1" SEIRAWAN = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR[HEhe] w KQBCDFGkqbcdfg - 0 1" GRAND = "r8r/1nbqkcabn1/pppppppppp/10/10/10/10/PPPPPPPPPP/1NBQKCABN1/R8R w - - 0 1" GRANDHOUSE = "r8r/1nbqkcabn1/pppppppppp/10/10/10/10/PPPPPPPPPP/1NBQKCABN1/R8R[] w - - 0 1" XIANGQI = "rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR w - - 0 1" SHOGUN = "rnb+fkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB+FKBNR w KQkq - 0 1" JANGGI = "rnba1abnr/4k4/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/4K4/RNBA1ABNR w - - 0 1" ini_text = """ # Hybrid variant of Grand-chess and crazyhouse, using Grand-chess as a template [grandhouse:grand] startFen = r8r/1nbqkcabn1/pppppppppp/10/10/10/10/PPPPPPPPPP/1NBQKCABN1/R8R[] w - - 0 1 pieceDrops = true capturesToHand = true # Shogun chess [shogun:crazyhouse] startFen = rnb+fkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNB+FKBNR w KQkq - 0 1 commoner = c centaur = g archbishop = a chancellor = m fers = f promotionRank = 6 promotionLimit = g:1 a:1 m:1 q:1 promotionPieceTypes = - promotedPieceType = p:c n:g b:a r:m f:q mandatoryPawnPromotion = false firstRankPawnDrops = true promotionZonePawnDrops = true whiteDropRegion = *1 *2 *3 *4 *5 blackDropRegion = *4 *5 *6 *7 *8 immobilityIllegal = true # Asymmetric variant with one army using pieces that move like knights but attack like other pieces (kniroo and knibis) [orda:chess] startFen = lhaykahl/8/pppppppp/8/8/8/PPPPPPPP/RNBQKBNR w KQ - 0 1 centaur = h knibis = a kniroo = l silver = y promotionPieceTypes = qh flagPiece = k whiteFlag = *8 blackFlag = *1 """ print(ini_text, file=open("variants.ini", "w")) sf.set_option("VariantPath", "variants.ini") variant_positions = { "chess": { "k7/8/8/8/8/8/8/K7 w - - 0 1": (True, True), # K vs K "k7/b7/8/8/8/8/8/K7 w - - 0 1": (True, True), # K vs KB "k7/n7/8/8/8/8/8/K7 w - - 0 1": (True, True), # K vs KN "k7/p7/8/8/8/8/8/K7 w - - 0 1": (True, False), # K vs KP "k7/r7/8/8/8/8/8/K7 w - - 0 1": (True, False), # K vs KR "k7/q7/8/8/8/8/8/K7 w - - 0 1": (True, False), # K vs KQ "k7/nn6/8/8/8/8/8/K7 w - - 0 1": (True, False), # K vsNN K "k7/bb6/8/8/8/8/8/K7 w - - 0 1": (True, False), # K vs KBB opp color "k7/b1b5/8/8/8/8/8/K7 w - - 0 1": (True, True), # K vs KBB same color "kb6/8/8/8/8/8/8/K1B6 w - - 0 1": (True, True), # KB vs KB same color "kb6/8/8/8/8/8/8/KB7 w - - 0 1": (False, False), # KB vs KB opp color }, "seirawan": { "k7/8/8/8/8/8/8/K7[] w - - 0 1": (True, True), # K vs K "k7/8/8/8/8/8/8/KH6[] w - - 0 1": (False, True), # KH vs K "k7/8/8/8/8/8/8/4K3[E] w E - 0 1": (False, True), # KE vs K }, "sittuyin": { "8/8/4pppp/pppp4/4PPPP/PPPP4/8/8[KFRRSSNNkfrrssnn] w - - 0 1": (False, False), # starting position "k7/8/8/8/8/8/8/K7[] w - - 0 1": (True, True), # K vs K "k6P/8/8/8/8/8/8/K7[] w - - 0 1": (True, True), # KP vs K "k6P/8/8/8/8/8/8/K6p[] w - - 0 1": (False, False), # KP vs KP "k7/8/8/8/8/8/8/KFF5[] w - - 0 1": (False, True), # KFF vs K "k7/8/8/8/8/8/8/KS6[] w - - 0 1": (False, True), # KS vs K }, "xiangqi": { "rnbakabnr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RNBAKABNR w - - 0 1": (False, False), # starting position "5k3/4a4/3CN4/9/1PP5p/9/8P/4C4/4A4/2B1K4 w - - 0 46": (False, False), # issue #53 "4k4/9/9/9/9/9/9/9/9/4K4 w - - 0 1": (True, True), # K vs K "4k4/9/9/4p4/9/9/9/9/9/4KR3 w - - 0 1": (False, False), # KR vs KP "4k4/9/9/9/9/9/9/9/9/3KN4 w - - 0 1": (False, True), # KN vs K "4k4/9/4b4/9/9/9/9/4B4/9/4K4 w - - 0 1": (True, True), # KB vs KB "4k4/9/9/9/9/9/9/9/4A4/4KC3 w - - 0 1": (False, True), # KCA vs K }, "janggi": { JANGGI: (False, False), # starting position "5k3/4a4/3CN4/9/1PP5p/9/8P/4C4/4A4/2B1K4 w - - 0 46": (False, False), # issue #53 "4k4/9/9/9/9/4B4/4B4/9/9/4K4 w - - 0 1": (False, True), # KEE vs K "4k4/9/9/9/9/9/9/9/4A4/4KC3 w - - 0 1": (False, True), # KCA vs K }, "shako": { "k9/10/10/10/10/10/10/10/10/KC8 w - - 0 1": (True, True), # KC vs K "k9/10/10/10/10/10/10/10/10/KCC7 w - - 0 1": (False, True), # KCC vs K "k9/10/10/10/10/10/10/10/10/KEC7 w - - 0 1": (False, True), # KEC vs K "k9/10/10/10/10/10/10/10/10/KNE7 w - - 0 1": (False, True), # KNE vs K "kb8/10/10/10/10/10/10/10/10/KE8 w - - 0 1": (False, False), # KE vs KB opp color "kb8/10/10/10/10/10/10/10/10/K1E7 w - - 0 1": (True, True), # KE vs KB same color }, "orda": { "k7/8/8/8/8/8/8/K7 w - - 0 1": (False, False), # K vs K }, } class TestPyffish(unittest.TestCase): def test_info(self): result = sf.info() self.assertEqual(result[:15], "Fairy-Stockfish") def test_set_option(self): result = sf.set_option("UCI_Variant", "capablanca") self.assertIsNone(result) def test_two_boards(self): self.assertFalse(sf.two_boards("chess")) self.assertTrue(sf.two_boards("bughouse")) def test_start_fen(self): result = sf.start_fen("capablanca") self.assertEqual(result, CAPA) result = sf.start_fen("capahouse") self.assertEqual(result, CAPAHOUSE) result = sf.start_fen("xiangqi") self.assertEqual(result, XIANGQI) result = sf.start_fen("grandhouse") self.assertEqual(result, GRANDHOUSE) result = sf.start_fen("shogun") self.assertEqual(result, SHOGUN) def test_legal_moves(self): fen = "10/10/10/10/10/k9/10/K9 w - - 0 1" result = sf.legal_moves("capablanca", fen, []) self.assertEqual(result, ["a1b1"]) result = sf.legal_moves("grand", GRAND, ["a3a5"]) self.assertIn("a10b10", result) result = sf.legal_moves("xiangqi", XIANGQI, ["h3h10"]) self.assertIn("i10h10", result) result = sf.legal_moves("xiangqi", XIANGQI, ["h3h10"]) self.assertIn("i10h10", result) result = sf.legal_moves("shogun", SHOGUN, ["c2c4", "b8c6", "b2b4", "b7b5", "c4b5", "c6b8"]) self.assertIn("b5b6+", result) # In Janggi stalemate position pass move (in place king move) is possible fen = "4k4/c7R/9/3R1R3/9/9/9/9/9/3K5 b - - 0 1" result = sf.legal_moves("janggi", fen, []) self.assertEqual(result, ["e10e10"]) def test_short_castling(self): legals = ['f5f4', 'a7a6', 'b7b6', 'c7c6', 'd7d6', 'e7e6', 'i7i6', 'j7j6', 'a7a5', 'b7b5', 'c7c5', 'e7e5', 'i7i5', 'j7j5', 'b8a6', 'b8c6', 'h6g4', 'h6i4', 'h6j5', 'h6f7', 'h6g8', 'h6i8', 'd5a2', 'd5b3', 'd5f3', 'd5c4', 'd5e4', 'd5c6', 'd5e6', 'd5f7', 'd5g8', 'j8g8', 'j8h8', 'j8i8', 'e8f7', 'c8b6', 'c8d6', 'g6g2', 'g6g3', 'g6f4', 'g6g4', 'g6h4', 'g6e5', 'g6g5', 'g6i5', 'g6a6', 'g6b6', 'g6c6', 'g6d6', 'g6e6', 'g6f6', 'g6h8', 'f8f7', 'f8g8', 'f8i8'] moves = ['b2b4', 'f7f5', 'c2c3', 'g8d5', 'a2a4', 'h8g6', 'f2f3', 'i8h6', 'h2h3'] result = sf.legal_moves("capablanca", CAPA, moves) self.assertEqual(legals, result) self.assertIn("f8i8", result) moves = ['a2a4', 'f7f5', 'b2b3', 'g8d5', 'b1a3', 'i8h6', 'c1a2', 'h8g6', 'c2c4'] result = sf.legal_moves("capablanca", CAPA, moves) self.assertIn("f8i8", result) moves = ['f2f4', 'g7g6', 'g1d4', 'j7j6', 'h1g3', 'b8a6', 'i1h3', 'h7h6'] result = sf.legal_moves("capablanca", CAPA, moves) self.assertIn("f1i1", result) def test_get_fen(self): result = sf.get_fen("chess", CHESS, []) self.assertEqual(result, CHESS) result = sf.get_fen("capablanca", CAPA, []) self.assertEqual(result, CAPA) result = sf.get_fen("xiangqi", XIANGQI, []) self.assertEqual(result, XIANGQI) fen = "rnab1kbcnr/ppppPppppp/10/4q5/10/10/PPPPP1PPPP/RNABQKBCNR[p] b KQkq - 0 3" result = sf.get_fen("capahouse", CAPA, ["f2f4", "e7e5", "f4e5", "e8e5", "P@e7"]) self.assertEqual(result, fen) fen0 = "reb1k2r/ppppqppp/2nb1n2/4p3/4P3/N1P2N2/PB1PQPPP/RE2KBHR[h] b KQkqac - 2 6" fen1 = "reb2rk1/ppppqppp/2nb1n2/4p3/4P3/N1P2N2/PB1PQPPP/RE2KBHR[h] w KQac - 3 7" result = sf.get_fen("seirawan", fen0, ["e8g8"]) self.assertEqual(result, fen1) result = sf.get_fen("chess", CHESS, [], True, False, False) self.assertEqual(result, CHESS960) # test O-O-O fen = "rbkqnrbn/pppppppp/8/8/8/8/PPPPPPPP/RBKQNRBN w AFaf - 0 1" moves = ["d2d4", "f7f5", "e1f3", "h8g6", "h1g3", "c7c6", "c2c3", "e7e6", "b1d3", "d7d5", "d1c2", "b8d6", "e2e3", "d8d7", "c1a1"] result = sf.get_fen("chess", fen, moves, True, False, False) self.assertEqual(result, "r1k1nrb1/pp1q2pp/2pbp1n1/3p1p2/3P4/2PBPNN1/PPQ2PPP/2KR1RB1 b fa - 2 8", CHESS960) # SFEN result = sf.get_fen("shogi", SHOGI, [], False, True) self.assertEqual(result, SHOGI_SFEN) # makruk FEN fen = "rnsmksnr/8/1pM~1pppp/p7/8/PPPP1PPP/8/RNSKMSNR b - - 0 3" result = sf.get_fen("makruk", MAKRUK, ["e3e4", "d6d5", "e4d5", "a6a5", "d5c6m"], False, False, True) self.assertEqual(result, fen) result = sf.get_fen("makruk", fen, [], False, False, True) self.assertEqual(result, fen) # makruk piece honor counting fen = "8/3k4/8/2K1S1P1/8/8/8/8 w - - 0 1" moves = ["g5g6m"] result = sf.get_fen("makruk", fen, moves, False, False, True) self.assertEqual(result, "8/3k4/6M~1/2K1S3/8/8/8/8 b - 88 8 1") fen = "8/2K3k1/5m2/4S1S1/8/8/8/8 w - 128 97 1" moves = ["e5f6"] result = sf.get_fen("makruk", fen, moves, False, False, True) self.assertEqual(result, "8/2K3k1/5S2/6S1/8/8/8/8 b - 44 8 1") # makruk board honor counting fen = "3k4/2m5/8/4MP2/3KS3/8/8/8 w - - 0 1" moves = ["f5f6m"] result = sf.get_fen("makruk", fen, moves, False, False, True) self.assertEqual(result, "3k4/2m5/5M~2/4M3/3KS3/8/8/8 b - 128 0 1") fen = "3k4/2m5/5M~2/4M3/3KS3/8/8/8 w - 128 0 33" moves = ["d4d5"] result = sf.get_fen("makruk", fen, moves, False, False, True) self.assertEqual(result, "3k4/2m5/5M~2/3KM3/4S3/8/8/8 b - 128 1 33") fen = "3k4/2m5/5M~2/4M3/3KS3/8/8/8 w - 128 36 1" moves = ["d4d5"] result = sf.get_fen("makruk", fen, moves, False, False, True) self.assertEqual(result, "3k4/2m5/5M~2/3KM3/4S3/8/8/8 b - 128 37 1") fen = "3k4/2m5/5M~2/4M3/3KS3/8/8/8 w - 128 0 33" moves = ["d4d5"] result = sf.get_fen("makruk", fen, moves, False, False, True, -1) self.assertEqual(result, "3k4/2m5/5M~2/3KM3/4S3/8/8/8 b - 128 0 33") fen = "3k4/2m5/5M~2/4M3/3KS3/8/8/8 w - 128 7 33" moves = ["d4d5"] result = sf.get_fen("makruk", fen, moves, False, False, True, 58) self.assertEqual(result, "3k4/2m5/5M~2/3KM3/4S3/8/8/8 b - 128 8 33") def test_get_san(self): fen = "4k3/8/3R4/8/1R3R2/8/3R4/4K3 w - - 0 1" result = sf.get_san("chess", fen, "b4d4") self.assertEqual(result, "Rbd4") result = sf.get_san("chess", fen, "f4d4") self.assertEqual(result, "Rfd4") result = sf.get_san("chess", fen, "d2d4") self.assertEqual(result, "R2d4") result = sf.get_san("chess", fen, "d6d4") self.assertEqual(result, "R6d4") fen = "4k3/8/3R4/3P4/1RP1PR2/8/3R4/4K3 w - - 0 1" result = sf.get_san("chess", fen, "d2d4") self.assertEqual(result, "Rd4") fen = "1r2k3/P1P5/8/8/8/8/8/4K3 w - - 0 1" result = sf.get_san("chess", fen, "c7b8q") self.assertEqual(result, "cxb8=Q+") fen = "1r2k3/P1P5/8/8/8/8/8/4K3 w - - 0 1" result = sf.get_san("chess", fen, "c7b8q", False, sf.NOTATION_LAN) self.assertEqual(result, "c7xb8=Q+") result = sf.get_san("capablanca", CAPA, "e2e4") self.assertEqual(result, "e4") result = sf.get_san("capablanca", CAPA, "e2e4", False, sf.NOTATION_LAN) self.assertEqual(result, "e2-e4") result = sf.get_san("capablanca", CAPA, "h1i3") self.assertEqual(result, "Ci3") result = sf.get_san("sittuyin", SITTUYIN, "R@a1") self.assertEqual(result, "R@a1") fen = "3rr3/1kn3n1/1ss1p1pp/1pPpP3/6PP/p3KN2/2SSFN2/3R3R[] b - - 0 14" result = sf.get_san("sittuyin", fen, "c6c5") self.assertEqual(result, "Scxc5") fen = "7R/1r6/3k1np1/3s2N1/3s3P/4n3/6p1/2R3K1[] w - - 2 55" result = sf.get_san("sittuyin", fen, "h4h4f") self.assertEqual(result, "h4=F") fen = "k7/2K3P1/8/4P3/8/8/8/1R6[] w - - 0 1" result = sf.get_san("sittuyin", fen, "e5f6f") self.assertEqual(result, "e5f6=F") result = sf.get_san("shogi", SHOGI, "i3i4") self.assertEqual(result, "P-16") result = sf.get_san("shogi", SHOGI, "i3i4", False, sf.NOTATION_SHOGI_HOSKING) self.assertEqual(result, "P16") result = sf.get_san("shogi", SHOGI, "f1e2", False, sf.NOTATION_SHOGI_HOSKING) self.assertEqual(result, "G49-58") result = sf.get_san("shogi", SHOGI, "f1e2", False, sf.NOTATION_SHOGI_HODGES) self.assertEqual(result, "G4i-5h") result = sf.get_san("shogi", SHOGI, "f1e2", False, sf.NOTATION_SHOGI_HODGES_NUMBER) self.assertEqual(result, "G49-58") fen = "lnsgkgsnl/1r5b1/pppppp1pp/6p2/9/2P6/PP1PPPPPP/1B5R1/LNSGKGSNL w -" result = sf.get_san("shogi", fen, "b2h8", False, sf.NOTATION_SHOGI_HODGES) self.assertEqual(result, "Bx2b=") result = sf.get_san("shogi", fen, "b2h8+", False, sf.NOTATION_SHOGI_HODGES) self.assertEqual(result, "Bx2b+") fen = "lnsgkg1nl/1r5s1/pppppp1pp/6p2/9/2P6/PP1PPPPPP/7R1/LNSGKGSNL[Bb] w " result = sf.get_san("shogi", fen, "B@g7", False, sf.NOTATION_SHOGI_HODGES) self.assertEqual(result, "B*3c") result = sf.get_san("shogi", fen, "B@g7", False, sf.NOTATION_SHOGI_HODGES_NUMBER) self.assertEqual(result, "B*33") fen = "lnsgkg1nl/1r4s+B1/pppppp1pp/6p2/9/2P6/PP1PPPPPP/7R1/LNSGKGSNL[B] w " result = sf.get_san("shogi", fen, "h8g7", False, sf.NOTATION_SHOGI_HODGES) self.assertEqual(result, "+B-3c") fen = "lnk2gsnl/7b1/p1p+SGp1pp/6p2/1pP6/4P4/PP3PPPP/1S2G2R1/L2GK1bNL[PRppns] w " result = sf.get_san("shogi", fen, "d7d8", False, sf.NOTATION_SHOGI_HODGES) self.assertEqual(result, "+S-6b") result = sf.get_san("xiangqi", XIANGQI, "h1g3") self.assertEqual(result, "Hg3") result = sf.get_san("xiangqi", XIANGQI, "h1g3", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "H2+3") result = sf.get_san("xiangqi", XIANGQI, "c1e3") self.assertEqual(result, "Ece3") result = sf.get_san("xiangqi", XIANGQI, "c1e3", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "E7+5") result = sf.get_san("xiangqi", XIANGQI, "h3h10") self.assertEqual(result, "Cxh10") result = sf.get_san("xiangqi", XIANGQI, "h3h10", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "C2+7") result = sf.get_san("xiangqi", XIANGQI, "h3h5") self.assertEqual(result, "Ch5") # skip disambiguation for elephants and advisors, but not for pieces that require it fen = "rnbakabnr/9/1c5c1/p1p1p1p1p/9/1NB6/P1P1P1P1P/1C1A3C1/9/RNBAK21R w - - 0 1" result = sf.get_san("xiangqi", fen, "c5e3", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "E7-5") result = sf.get_san("xiangqi", fen, "d1e2", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "A6+5") result = sf.get_san("xiangqi", fen, "b5c7", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "H++7") # Tandem pawns fen = "rnbakabnr/9/1c5c1/p1p1P1p1p/4P4/9/P3P3P/1C5C1/9/RNBAKABNR w - - 0 1" result = sf.get_san("xiangqi", fen, "e7d7", False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, "15=6") result = sf.get_san("janggi", JANGGI, "b1c3", False, sf.NOTATION_JANGGI) self.assertEqual(result, "H02-83") fen = "1rb1ka2r/4a4/2ncb1nc1/p1p1p1p1p/9/2P6/P3PNP1P/2N1C2C1/9/R1BAKAB1R w - - 1 7" result = sf.get_san("xiangqi", fen, "c3e2") self.assertEqual(result, "Hce2") result = sf.get_san("xiangqi", fen, "c3d5") self.assertEqual(result, "Hd5") fen = "rnsm1s1r/4n1k1/1ppppppp/p7/2PPP3/PP3PPP/4N2R/RNSKMS2 b - - 1 5" result = sf.get_san("makruk", fen, "f8f7") self.assertEqual(result, "Sf7") fen = "4k3/8/8/4S3/8/2S5/8/4K3 w - - 0 1" result = sf.get_san("makruk", fen, "e5d4") self.assertEqual(result, "Sed4") result = sf.get_san("makruk", fen, "c3d4") self.assertEqual(result, "Scd4") fen = "4k3/8/8/3S4/8/3S4/8/4K3 w - - 0 1" result = sf.get_san("makruk", fen, "d3d4") self.assertEqual(result, "Sd4") UCI_moves = ["e2e4", "e7e5", "g1f3", "b8c6h", "f1c4", "f8c5e"] SAN_moves = ["e4", "e5", "Nf3", "Nc6/H", "Bc4", "Bc5/E"] fen = SEIRAWAN for i, move in enumerate(UCI_moves): result = sf.get_san("seirawan", fen, move) self.assertEqual(result, SAN_moves[i]) fen = sf.get_fen("seirawan", SEIRAWAN, UCI_moves[:i + 1]) result = sf.get_san("seirawan", fen, "e1g1") self.assertEqual(result, "O-O") result = sf.get_san("seirawan", fen, "e1g1h") self.assertEqual(result, "O-O/He1") result = sf.get_san("seirawan", fen, "e1g1e") self.assertEqual(result, "O-O/Ee1") result = sf.get_san("seirawan", fen, "h1e1h") self.assertEqual(result, "O-O/Hh1") result = sf.get_san("seirawan", fen, "h1e1e") self.assertEqual(result, "O-O/Eh1") def test_get_san_moves(self): UCI_moves = ["e2e4", "e7e5", "g1f3", "b8c6h", "f1c4", "f8c5e"] SAN_moves = ["e4", "e5", "Nf3", "Nc6/H", "Bc4", "Bc5/E"] result = sf.get_san_moves("seirawan", SEIRAWAN, UCI_moves) self.assertEqual(result, SAN_moves) UCI_moves = ["c3c4", "g7g6", "b2h8"] SAN_moves = ["P-76", "P-34", "Bx22="] result = sf.get_san_moves("shogi", SHOGI, UCI_moves) self.assertEqual(result, SAN_moves) UCI_moves = ["h3e3", "h10g8", "h1g3", "c10e8", "a1a3", "i10h10"] SAN_moves = ["C2=5", "H8+7", "H2+3", "E3+5", "R9+2", "R9=8"] result = sf.get_san_moves("xiangqi", XIANGQI, UCI_moves, False, sf.NOTATION_XIANGQI_WXF) self.assertEqual(result, SAN_moves) UCI_moves = ["e2e4", "d7d5", "f1a6+", "d8d6"] SAN_moves = ["e4", "d5", "Ba6=A", "Qd6"] result = sf.get_san_moves("shogun", SHOGUN, UCI_moves) self.assertEqual(result, SAN_moves) def test_gives_check(self): result = sf.gives_check("capablanca", CAPA, []) self.assertFalse(result) result = sf.gives_check("capablanca", CAPA, ["e2e4"]) self.assertFalse(result) moves = ["g2g3", "d7d5", "a2a3", "c8h3"] result = sf.gives_check("capablanca", CAPA, moves) self.assertTrue(result) def test_game_result(self): result = sf.game_result("chess", CHESS, ["f2f3", "e7e5", "g2g4", "d8h4"]) self.assertTrue(result < 0) def test_is_immediate_game_end(self): result = sf.is_immediate_game_end("capablanca", CAPA, []) self.assertFalse(result[0]) # bikjang (facing kings) moves = "e2e3 e9f9 h3d3 e7f7 i1i3 h10i8 i3h3 c10e7 h3h8 i10i9 h8b8 i9g9 d3f3 f9e9 f3f10 e7c10 f10c10 b10c8 c10g10 g9f9 b8c8 a10b10 b3f3 f9h9 a1a2 h9f9 a2d2 b10b9 d2d10 e9d10 c8c10 d10d9 f3f9 i8g9 f9b9 a7a6 g10g7 f7f6 e4e5 c7d7 g1e4 i7i6 e4b6 d9d8 c10c8 d8d9 b9g9 d7d6 b6e8 i6h6 e5e6 f6e6 c1e4 a6b6 e4b6 d6d5 c4c5 d9d10 e3d3 h6i6 c5c6 d5c5" result = sf.is_immediate_game_end("janggi", JANGGI, moves.split()) self.assertFalse(result[0]) moves = "e2e3 e9f9 h3d3 e7f7 i1i3 h10i8 i3h3 c10e7 h3h8 i10i9 h8b8 i9g9 d3f3 f9e9 f3f10 e7c10 f10c10 b10c8 c10g10 g9f9 b8c8 a10b10 b3f3 f9h9 a1a2 h9f9 a2d2 b10b9 d2d10 e9d10 c8c10 d10d9 f3f9 i8g9 f9b9 a7a6 g10g7 f7f6 e4e5 c7d7 g1e4 i7i6 e4b6 d9d8 c10c8 d8d9 b9g9 d7d6 b6e8 i6h6 e5e6 f6e6 c1e4 a6b6 e4b6 d6d5 c4c5 d9d10 e3d3 h6i6 c5c6 d5c5 d3d3" result = sf.is_immediate_game_end("janggi", JANGGI, moves.split()) self.assertTrue(result[0]) self.assertTrue(result[1] < 0) def test_is_optional_game_end(self): result = sf.is_optional_game_end("capablanca", CAPA, []) self.assertFalse(result[0]) def test_has_insufficient_material(self): for variant, positions in variant_positions.items(): for fen, expected_result in positions.items(): result = sf.has_insufficient_material(variant, fen, []) self.assertEqual(result, expected_result, "{}: {}".format(variant, fen)) if __name__ == '__main__': unittest.main(verbosity=2) Fairy-Stockfish-fairy_sf_11_1/tests/000077500000000000000000000000001366242550200175535ustar00rootroot00000000000000Fairy-Stockfish-fairy_sf_11_1/tests/instrumented.sh000077500000000000000000000061041366242550200226340ustar00rootroot00000000000000#!/bin/bash # check for errors under valgrind or sanitizers. error() { echo "instrumented testing failed on line $1" exit 1 } trap 'error ${LINENO}' ERR # define suitable post and prefixes for testing options case $1 in --valgrind) echo "valgrind testing started" prefix='' exeprefix='valgrind --error-exitcode=42' postfix='1>/dev/null' threads="1" ;; --valgrind-thread) echo "valgrind-thread testing started" prefix='' exeprefix='valgrind --error-exitcode=42' postfix='1>/dev/null' threads="2" ;; --sanitizer-undefined) echo "sanitizer-undefined testing started" prefix='!' exeprefix='' postfix='2>&1 | grep -A50 "runtime error:"' threads="1" ;; --sanitizer-thread) echo "sanitizer-thread testing started" prefix='!' exeprefix='' postfix='2>&1 | grep -A50 "WARNING: ThreadSanitizer:"' threads="2" cat << EOF > tsan.supp race:TTEntry::move race:TTEntry::depth race:TTEntry::bound race:TTEntry::save race:TTEntry::value race:TTEntry::eval race:TTEntry::is_pv race:TranspositionTable::probe race:TranspositionTable::hashfull EOF export TSAN_OPTIONS="suppressions=./tsan.supp" ;; *) echo "unknown testing started" prefix='' exeprefix='' postfix='' threads="1" ;; esac # simple command line testing for args in "eval" \ "go nodes 1000" \ "go depth 10" \ "go movetime 1000" \ "go wtime 8000 btime 8000 winc 500 binc 500" \ "bench 128 $threads 8 default depth" do echo "$prefix $exeprefix ./stockfish $args $postfix" eval "$prefix $exeprefix ./stockfish $args $postfix" done # more general testing, following an uci protocol exchange cat << EOF > game.exp set timeout 60 spawn $exeprefix ./stockfish send "uci\n" expect "uciok" send "setoption name Threads value $threads\n" send "ucinewgame\n" send "position startpos\n" send "go nodes 1000\n" expect "bestmove" send "position startpos moves e2e4 e7e6\n" send "go nodes 1000\n" expect "bestmove" send "position fen 5rk1/1K4p1/8/8/3B4/8/8/8 b - - 0 1\n" send "go depth 20\n" expect "bestmove" send "quit\n" expect eof # return error code of the spawned program, useful for valgrind lassign [wait] pid spawnid os_error_flag value exit \$value EOF #download TB as needed if [ ! -d ../tests/syzygy ]; then curl -sL https://api.github.com/repos/niklasf/python-chess/tarball/9b9aa13f9f36d08aadfabff872882f4ab1494e95 | tar -xzf - mv niklasf-python-chess-9b9aa13 ../tests/syzygy fi cat << EOF > syzygy.exp set timeout 600 spawn $exeprefix ./stockfish send "uci\n" send "setoption name SyzygyPath value ../tests/syzygy/\n" expect "info string Found 35 tablebases" {} timeout {exit 1} send "bench 128 1 8 default depth\n" send "quit\n" expect eof # return error code of the spawned program, useful for valgrind lassign [wait] pid spawnid os_error_flag value exit \$value EOF for exp in game.exp syzygy.exp do echo "$prefix expect $exp $postfix" eval "$prefix expect $exp $postfix" rm $exp done rm -f tsan.supp echo "instrumented testing OK" Fairy-Stockfish-fairy_sf_11_1/tests/perft.sh000077500000000000000000000101471366242550200212350ustar00rootroot00000000000000#!/bin/bash # verify perft numbers (positions from www.chessprogramming.org/Perft_Results) error() { echo "perft testing failed on line $1" exit 1 } trap 'error ${LINENO}' ERR echo "perft testing started" cat << EOF > perft.exp set timeout 60 lassign \$argv var pos depth result spawn ./stockfish send "setoption name UCI_Variant value \$var\\n" send "position \$pos\\ngo perft \$depth\\n" expect "Nodes searched? \$result" {} timeout {exit 1} send "quit\\n" expect eof EOF # chess if [[ $1 == "" || $1 == "chess" ]]; then expect perft.exp chess startpos 5 4865609 > /dev/null expect perft.exp chess "fen r3k2r/p1ppqpb1/bn2pnp1/3PN3/1p2P3/2N2Q1p/PPPBBPPP/R3K2R w KQkq -" 5 193690690 > /dev/null expect perft.exp chess "fen 8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - -" 6 11030083 > /dev/null expect perft.exp chess "fen r3k2r/Pppp1ppp/1b3nbN/nP6/BBP1P3/q4N2/Pp1P2PP/R2Q1RK1 w kq - 0 1" 5 15833292 > /dev/null expect perft.exp chess "fen rnbq1k1r/pp1Pbppp/2p5/8/2B5/8/PPP1NnPP/RNBQK2R w KQ - 1 8" 5 89941194 > /dev/null expect perft.exp chess "fen r4rk1/1pp1qppp/p1np1n2/2b1p1B1/2B1P1b1/P1NP1N2/1PP1QPPP/R4RK1 w - - 0 10" 5 164075551 > /dev/null fi # variants if [[ $1 == "" || $1 == "variant" ]]; then expect perft.exp crazyhouse startpos 5 4888832 > /dev/null expect perft.exp losalamos startpos 6 2549164 > /dev/null expect perft.exp pocketknight startpos 4 3071267 > /dev/null expect perft.exp amazon startpos 5 9319911 > /dev/null expect perft.exp makruk startpos 5 6223994 > /dev/null expect perft.exp cambodian startpos 5 8601434 > /dev/null expect perft.exp shatranj startpos 5 1164248 > /dev/null expect perft.exp hoppelpoppel startpos 5 5056643 > /dev/null expect perft.exp newzealand startpos 5 4987426 > /dev/null expect perft.exp loop startpos 5 4888832 > /dev/null expect perft.exp chessgi startpos 5 4889167 > /dev/null expect perft.exp racingkings startpos 5 9472927 > /dev/null expect perft.exp knightmate startpos 5 3249033 > /dev/null expect perft.exp losers startpos 5 2723795 > /dev/null expect perft.exp antichess startpos 5 2732672 > /dev/null expect perft.exp giveaway startpos 5 2732672 > /dev/null expect perft.exp asean startpos 5 6223994 > /dev/null expect perft.exp ai-wok startpos 5 13275068 > /dev/null expect perft.exp euroshogi startpos 5 9451149 > /dev/null expect perft.exp minishogi startpos 5 533203 > /dev/null expect perft.exp kyotoshogi startpos 5 225903 > /dev/null expect perft.exp horde startpos 6 5396554 > /dev/null expect perft.exp placement startpos 4 1597696 > /dev/null expect perft.exp sittuyin startpos 3 580096 > /dev/null expect perft.exp sittuyin "fen 8/8/6R1/s3r3/P5R1/1KP3p1/1F2kr2/8[] b - - 0 72" 4 652686 > /dev/null expect perft.exp sittuyin "fen 2r5/6k1/6p1/3s2P1/3npR2/8/p2N2F1/3K4[] w - - 1 50" 4 373984 > /dev/null expect perft.exp sittuyin "fen 8/6s1/5P2/3n4/pR2K2S/1P6/1k4p1/8[] w - - 1 50" 4 268869 > /dev/null expect perft.exp seirawan startpos 5 27639803 > /dev/null expect perft.exp seirawan "fen reb1k2r/ppppqppp/2nb1n2/4p3/4P3/N1P2N2/PB1PQPPP/RE2KBHR[h] b KQkqc - 3 7" 5 31463761 > /dev/null fi # large-board variants if [[ $1 == "largeboard" ]]; then expect perft.exp shogi startpos 4 719731 > /dev/null expect perft.exp capablanca startpos 4 805128 > /dev/null expect perft.exp embassy startpos 4 809539 > /dev/null expect perft.exp janus startpos 4 772074 > /dev/null expect perft.exp modern startpos 4 433729 > /dev/null expect perft.exp chancellor startpos 4 436656 > /dev/null expect perft.exp courier startpos 4 500337 > /dev/null expect perft.exp grand startpos 3 259514 > /dev/null expect perft.exp xiangqi startpos 4 3290240 > /dev/null expect perft.exp xiangqi "fen 1rbaka2R/5r3/6n2/2p1p1p2/4P1bP1/PpC3Bc1/1nPR2P2/2N2AN2/1c2K1p2/2BAC4 w - - 0 1" 4 4485547 > /dev/null expect perft.exp janggi startpos 4 1065277 > /dev/null expect perft.exp janggi "fen 1n1kaabn1/cr2N4/5C1c1/p1pNp3p/9/9/P1PbP1P1P/3r1p3/4A4/R1BA1KB1R b - - 0 1" 4 76763 > /dev/null expect perft.exp janggi "fen 1Pbcka3/3nNn1c1/N2CaC3/1pB6/9/9/5P3/9/4K4/9 w - - 0 23" 4 151202 > /dev/null fi rm perft.exp echo "perft testing OK" Fairy-Stockfish-fairy_sf_11_1/tests/protocol.sh000077500000000000000000000014751366242550200217620ustar00rootroot00000000000000#!/bin/bash # verify protocol implementations error() { echo "protocol testing failed on line $1" exit 1 } trap 'error ${LINENO}' ERR echo "protocol testing started" cat << EOF > uci.exp set timeout 5 spawn ./stockfish send "uci\\n" expect "default chess" expect "uciok" send "usi\\n" expect "default shogi" expect "usiok" send "ucci\\n" expect "option UCI_Variant" expect "default xiangqi" expect "ucciok" send "quit\\n" expect eof EOF cat << EOF > xboard.exp set timeout 5 spawn ./stockfish send "xboard\\n" send "protover 2\\n" expect "feature done=1" send "ping\\n" expect "pong" send "ping\\n" expect "pong" send "quit\\n" expect eof EOF for exp in uci.exp xboard.exp do expect $exp > /dev/null rm $exp done echo "protocol testing OK" Fairy-Stockfish-fairy_sf_11_1/tests/reprosearch.sh000077500000000000000000000023751366242550200224360ustar00rootroot00000000000000#!/bin/bash # verify reproducible search error() { echo "reprosearch testing failed on line $1" exit 1 } trap 'error ${LINENO}' ERR echo "reprosearch testing started" # repeat two short games, separated by ucinewgame. # with go nodes $nodes they should result in exactly # the same node count for each iteration. cat << EOF > repeat.exp set timeout 10 spawn ./stockfish lassign \$argv nodes send "uci\n" expect "uciok" send "ucinewgame\n" send "position startpos\n" send "go nodes \$nodes\n" expect "bestmove" send "position startpos moves e2e4 e7e6\n" send "go nodes \$nodes\n" expect "bestmove" send "ucinewgame\n" send "position startpos\n" send "go nodes \$nodes\n" expect "bestmove" send "position startpos moves e2e4 e7e6\n" send "go nodes \$nodes\n" expect "bestmove" send "quit\n" expect eof EOF # to increase the likelyhood of finding a non-reproducible case, # the allowed number of nodes are varied systematically for i in `seq 1 20` do nodes=$((100*3**i/2**i)) echo "reprosearch testing with $nodes nodes" # each line should appear exactly an even number of times expect repeat.exp $nodes 2>&1 | grep -o "nodes [0-9]*" | sort | uniq -c | awk '{if ($1%2!=0) exit(1)}' done rm repeat.exp echo "reprosearch testing OK" Fairy-Stockfish-fairy_sf_11_1/tests/signature.sh000077500000000000000000000013761366242550200221220ustar00rootroot00000000000000#!/bin/bash # obtain and optionally verify Bench / signature # if no reference is given, the output is deliberately limited to just the signature error() { echo "running bench for signature failed on line $1" exit 1 } trap 'error ${LINENO}' ERR # obtain signature=`./stockfish bench 2>&1 | grep "Nodes searched : " | awk '{print $4}'` if [ $# -gt 0 ]; then # compare to given reference if [ "$1" != "$signature" ]; then if [ -z "$signature" ]; then echo "No signature obtained from bench. Code crashed or assert triggered ?" else echo "signature mismatch: reference $1 obtained: $signature ." fi exit 1 else echo "signature OK: $signature" fi else # just report signature echo $signature fi