├── .gitignore ├── .idea ├── .gitignore ├── inspectionProfiles │ ├── Project_Default.xml │ └── profiles_settings.xml ├── misc.xml ├── modules.xml ├── sunfish.iml └── vcs.xml ├── LICENSE.md ├── README.md ├── draw_board.py ├── screenshot ├── chess_board_chinese.png ├── chess_board_unicode.png ├── xiangqi_chinese.png └── xiangqi_unicode.png └── xiangqi.py /.gitignore: -------------------------------------------------------------------------------- 1 | 2 | # Created by https://www.toptal.com/developers/gitignore/api/python,pycharm,vscode 3 | # Edit at https://www.toptal.com/developers/gitignore?templates=python,pycharm,vscode 4 | 5 | ### PyCharm ### 6 | # Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider 7 | # Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 8 | 9 | # User-specific stuff 10 | .idea/**/workspace.xml 11 | .idea/**/tasks.xml 12 | .idea/**/usage.statistics.xml 13 | .idea/**/dictionaries 14 | .idea/**/shelf 15 | 16 | # Generated files 17 | .idea/**/contentModel.xml 18 | 19 | # Sensitive or high-churn files 20 | .idea/**/dataSources/ 21 | .idea/**/dataSources.ids 22 | .idea/**/dataSources.local.xml 23 | .idea/**/sqlDataSources.xml 24 | .idea/**/dynamic.xml 25 | .idea/**/uiDesigner.xml 26 | .idea/**/dbnavigator.xml 27 | 28 | # Gradle 29 | .idea/**/gradle.xml 30 | .idea/**/libraries 31 | 32 | # Gradle and Maven with auto-import 33 | # When using Gradle or Maven with auto-import, you should exclude module files, 34 | # since they will be recreated, and may cause churn. Uncomment if using 35 | # auto-import. 36 | # .idea/artifacts 37 | # .idea/compiler.xml 38 | # .idea/jarRepositories.xml 39 | # .idea/modules.xml 40 | # .idea/*.iml 41 | # .idea/modules 42 | # *.iml 43 | # *.ipr 44 | 45 | # CMake 46 | cmake-build-*/ 47 | 48 | # Mongo Explorer plugin 49 | .idea/**/mongoSettings.xml 50 | 51 | # File-based project format 52 | *.iws 53 | 54 | # IntelliJ 55 | out/ 56 | 57 | # mpeltonen/sbt-idea plugin 58 | .idea_modules/ 59 | 60 | # JIRA plugin 61 | atlassian-ide-plugin.xml 62 | 63 | # Cursive Clojure plugin 64 | .idea/replstate.xml 65 | 66 | # Crashlytics plugin (for Android Studio and IntelliJ) 67 | com_crashlytics_export_strings.xml 68 | crashlytics.properties 69 | crashlytics-build.properties 70 | fabric.properties 71 | 72 | # Editor-based Rest Client 73 | .idea/httpRequests 74 | 75 | # Android studio 3.1+ serialized cache file 76 | .idea/caches/build_file_checksums.ser 77 | 78 | ### PyCharm Patch ### 79 | # Comment Reason: https://github.com/joeblau/gitignore.io/issues/186#issuecomment-215987721 80 | 81 | # *.iml 82 | # modules.xml 83 | # .idea/misc.xml 84 | # *.ipr 85 | 86 | # Sonarlint plugin 87 | # https://plugins.jetbrains.com/plugin/7973-sonarlint 88 | .idea/**/sonarlint/ 89 | 90 | # SonarQube Plugin 91 | # https://plugins.jetbrains.com/plugin/7238-sonarqube-community-plugin 92 | .idea/**/sonarIssues.xml 93 | 94 | # Markdown Navigator plugin 95 | # https://plugins.jetbrains.com/plugin/7896-markdown-navigator-enhanced 96 | .idea/**/markdown-navigator.xml 97 | .idea/**/markdown-navigator-enh.xml 98 | .idea/**/markdown-navigator/ 99 | 100 | # Cache file creation bug 101 | # See https://youtrack.jetbrains.com/issue/JBR-2257 102 | .idea/$CACHE_FILE$ 103 | 104 | # CodeStream plugin 105 | # https://plugins.jetbrains.com/plugin/12206-codestream 106 | .idea/codestream.xml 107 | 108 | ### Python ### 109 | # Byte-compiled / optimized / DLL files 110 | __pycache__/ 111 | *.py[cod] 112 | *$py.class 113 | 114 | # C extensions 115 | *.so 116 | 117 | # Distribution / packaging 118 | .Python 119 | build/ 120 | develop-eggs/ 121 | dist/ 122 | downloads/ 123 | eggs/ 124 | .eggs/ 125 | lib/ 126 | lib64/ 127 | parts/ 128 | sdist/ 129 | var/ 130 | wheels/ 131 | pip-wheel-metadata/ 132 | share/python-wheels/ 133 | *.egg-info/ 134 | .installed.cfg 135 | *.egg 136 | MANIFEST 137 | 138 | # PyInstaller 139 | # Usually these files are written by a python script from a template 140 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 141 | *.manifest 142 | *.spec 143 | 144 | # Installer logs 145 | pip-log.txt 146 | pip-delete-this-directory.txt 147 | 148 | # Unit test / coverage reports 149 | htmlcov/ 150 | .tox/ 151 | .nox/ 152 | .coverage 153 | .coverage.* 154 | .cache 155 | nosetests.xml 156 | coverage.xml 157 | *.cover 158 | *.py,cover 159 | .hypothesis/ 160 | .pytest_cache/ 161 | pytestdebug.log 162 | 163 | # Translations 164 | *.mo 165 | *.pot 166 | 167 | # Django stuff: 168 | *.log 169 | local_settings.py 170 | db.sqlite3 171 | db.sqlite3-journal 172 | 173 | # Flask stuff: 174 | instance/ 175 | .webassets-cache 176 | 177 | # Scrapy stuff: 178 | .scrapy 179 | 180 | # Sphinx documentation 181 | docs/_build/ 182 | doc/_build/ 183 | 184 | # PyBuilder 185 | target/ 186 | 187 | # Jupyter Notebook 188 | .ipynb_checkpoints 189 | 190 | # IPython 191 | profile_default/ 192 | ipython_config.py 193 | 194 | # pyenv 195 | .python-version 196 | 197 | # pipenv 198 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 199 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 200 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 201 | # install all needed dependencies. 202 | #Pipfile.lock 203 | 204 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 205 | __pypackages__/ 206 | 207 | # Celery stuff 208 | celerybeat-schedule 209 | celerybeat.pid 210 | 211 | # SageMath parsed files 212 | *.sage.py 213 | 214 | # Environments 215 | .env 216 | .venv 217 | env/ 218 | venv/ 219 | ENV/ 220 | env.bak/ 221 | venv.bak/ 222 | pythonenv* 223 | 224 | # Spyder project settings 225 | .spyderproject 226 | .spyproject 227 | 228 | # Rope project settings 229 | .ropeproject 230 | 231 | # mkdocs documentation 232 | /site 233 | 234 | # mypy 235 | .mypy_cache/ 236 | .dmypy.json 237 | dmypy.json 238 | 239 | # Pyre type checker 240 | .pyre/ 241 | 242 | # pytype static type analyzer 243 | .pytype/ 244 | 245 | # profiling data 246 | .prof 247 | 248 | ### vscode ### 249 | .vscode/* 250 | !.vscode/settings.json 251 | !.vscode/tasks.json 252 | !.vscode/launch.json 253 | !.vscode/extensions.json 254 | *.code-workspace 255 | 256 | # End of https://www.toptal.com/developers/gitignore/api/python,pycharm,vscode 257 | -------------------------------------------------------------------------------- /.idea/.gitignore: -------------------------------------------------------------------------------- 1 | # Default ignored files 2 | /shelf/ 3 | /workspace.xml 4 | # Datasource local storage ignored files 5 | /dataSources/ 6 | /dataSources.local.xml 7 | # Editor-based HTTP Client requests 8 | /httpRequests/ 9 | -------------------------------------------------------------------------------- /.idea/inspectionProfiles/Project_Default.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 34 | -------------------------------------------------------------------------------- /.idea/inspectionProfiles/profiles_settings.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 6 | -------------------------------------------------------------------------------- /.idea/misc.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /.idea/modules.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/sunfish.iml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.idea/vcs.xml: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | -------------------------------------------------------------------------------- /LICENSE.md: -------------------------------------------------------------------------------- 1 | GNU GENERAL PUBLIC LICENSE 2 | ========================== 3 | 4 | Version 3, 29 June 2007 5 | 6 | Copyright © 2007 Free Software Foundation, Inc. <> 7 | 8 | Everyone is permitted to copy and distribute verbatim copies of this license 9 | document, but changing it is not allowed. 10 | 11 | ## Preamble 12 | 13 | The GNU General Public License is a free, copyleft license for software and other 14 | kinds of works. 15 | 16 | The licenses for most software and other practical works are designed to take away 17 | your freedom to share and change the works. By contrast, the GNU General Public 18 | License is intended to guarantee your freedom to share and change all versions of a 19 | program--to make sure it remains free software for all its users. We, the Free 20 | Software Foundation, use the GNU General Public License for most of our software; it 21 | applies also to any other work released this way by its authors. You can apply it to 22 | your programs, too. 23 | 24 | When we speak of free software, we are referring to freedom, not price. Our General 25 | Public Licenses are designed to make sure that you have the freedom to distribute 26 | copies of free software (and charge for them if you wish), that you receive source 27 | code or can get it if you want it, that you can change the software or use pieces of 28 | it in new free programs, and that you know you can do these things. 29 | 30 | To protect your rights, we need to prevent others from denying you these rights or 31 | asking you to surrender the rights. Therefore, you have certain responsibilities if 32 | you distribute copies of the software, or if you modify it: responsibilities to 33 | respect the freedom of others. 34 | 35 | For example, if you distribute copies of such a program, whether gratis or for a fee, 36 | you must pass on to the recipients the same freedoms that you received. You must make 37 | sure that they, too, receive or can get the source code. And you must show them these 38 | terms so they know their rights. 39 | 40 | Developers that use the GNU GPL protect your rights with two steps: (1) assert 41 | copyright on the software, and (2) offer you this License giving you legal permission 42 | to copy, distribute and/or modify it. 43 | 44 | For the developers' and authors' protection, the GPL clearly explains that there is 45 | no warranty for this free software. For both users' and authors' sake, the GPL 46 | requires that modified versions be marked as changed, so that their problems will not 47 | be attributed erroneously to authors of previous versions. 48 | 49 | Some devices are designed to deny users access to install or run modified versions of 50 | the software inside them, although the manufacturer can do so. This is fundamentally 51 | incompatible with the aim of protecting users' freedom to change the software. The 52 | systematic pattern of such abuse occurs in the area of products for individuals to 53 | use, which is precisely where it is most unacceptable. Therefore, we have designed 54 | this version of the GPL to prohibit the practice for those products. If such problems 55 | arise substantially in other domains, we stand ready to extend this provision to 56 | those domains in future versions of the GPL, as needed to protect the freedom of 57 | users. 58 | 59 | Finally, every program is threatened constantly by software patents. States should 60 | not allow patents to restrict development and use of software on general-purpose 61 | computers, but in those that do, we wish to avoid the special danger that patents 62 | applied to a free program could make it effectively proprietary. To prevent this, the 63 | GPL assures that patents cannot be used to render the program non-free. 64 | 65 | The precise terms and conditions for copying, distribution and modification follow. 66 | 67 | ## TERMS AND CONDITIONS 68 | 69 | ### 0. Definitions. 70 | 71 | “This License” refers to version 3 of the GNU General Public License. 72 | 73 | “Copyright” also means copyright-like laws that apply to other kinds of 74 | works, such as semiconductor masks. 75 | 76 | “The Program” refers to any copyrightable work licensed under this 77 | License. Each licensee is addressed as “you”. “Licensees” and 78 | “recipients” may be individuals or organizations. 79 | 80 | To “modify” a work means to copy from or adapt all or part of the work in 81 | a fashion requiring copyright permission, other than the making of an exact copy. The 82 | resulting work is called a “modified version” of the earlier work or a 83 | work “based on” the earlier work. 84 | 85 | A “covered work” means either the unmodified Program or a work based on 86 | the Program. 87 | 88 | To “propagate” a work means to do anything with it that, without 89 | permission, would make you directly or secondarily liable for infringement under 90 | applicable copyright law, except executing it on a computer or modifying a private 91 | copy. Propagation includes copying, distribution (with or without modification), 92 | making available to the public, and in some countries other activities as well. 93 | 94 | To “convey” a work means any kind of propagation that enables other 95 | parties to make or receive copies. Mere interaction with a user through a computer 96 | network, with no transfer of a copy, is not conveying. 97 | 98 | An interactive user interface displays “Appropriate Legal Notices” to the 99 | extent that it includes a convenient and prominently visible feature that (1) 100 | displays an appropriate copyright notice, and (2) tells the user that there is no 101 | warranty for the work (except to the extent that warranties are provided), that 102 | licensees may convey the work under this License, and how to view a copy of this 103 | License. If the interface presents a list of user commands or options, such as a 104 | menu, a prominent item in the list meets this criterion. 105 | 106 | ### 1. Source Code. 107 | 108 | The “source code” for a work means the preferred form of the work for 109 | making modifications to it. “Object code” means any non-source form of a 110 | work. 111 | 112 | A “Standard Interface” means an interface that either is an official 113 | standard defined by a recognized standards body, or, in the case of interfaces 114 | specified for a particular programming language, one that is widely used among 115 | developers working in that language. 116 | 117 | The “System Libraries” of an executable work include anything, other than 118 | the work as a whole, that (a) is included in the normal form of packaging a Major 119 | Component, but which is not part of that Major Component, and (b) serves only to 120 | enable use of the work with that Major Component, or to implement a Standard 121 | Interface for which an implementation is available to the public in source code form. 122 | A “Major Component”, in this context, means a major essential component 123 | (kernel, window system, and so on) of the specific operating system (if any) on which 124 | the executable work runs, or a compiler used to produce the work, or an object code 125 | interpreter used to run it. 126 | 127 | The “Corresponding Source” for a work in object code form means all the 128 | source code needed to generate, install, and (for an executable work) run the object 129 | code and to modify the work, including scripts to control those activities. However, 130 | it does not include the work's System Libraries, or general-purpose tools or 131 | generally available free programs which are used unmodified in performing those 132 | activities but which are not part of the work. For example, Corresponding Source 133 | includes interface definition files associated with source files for the work, and 134 | the source code for shared libraries and dynamically linked subprograms that the work 135 | is specifically designed to require, such as by intimate data communication or 136 | control flow between those subprograms and other parts of the work. 137 | 138 | The Corresponding Source need not include anything that users can regenerate 139 | automatically from other parts of the Corresponding Source. 140 | 141 | The Corresponding Source for a work in source code form is that same work. 142 | 143 | ### 2. Basic Permissions. 144 | 145 | All rights granted under this License are granted for the term of copyright on the 146 | Program, and are irrevocable provided the stated conditions are met. This License 147 | explicitly affirms your unlimited permission to run the unmodified Program. The 148 | output from running a covered work is covered by this License only if the output, 149 | given its content, constitutes a covered work. This License acknowledges your rights 150 | of fair use or other equivalent, as provided by copyright law. 151 | 152 | You may make, run and propagate covered works that you do not convey, without 153 | conditions so long as your license otherwise remains in force. You may convey covered 154 | works to others for the sole purpose of having them make modifications exclusively 155 | for you, or provide you with facilities for running those works, provided that you 156 | comply with the terms of this License in conveying all material for which you do not 157 | control copyright. Those thus making or running the covered works for you must do so 158 | exclusively on your behalf, under your direction and control, on terms that prohibit 159 | them from making any copies of your copyrighted material outside their relationship 160 | with you. 161 | 162 | Conveying under any other circumstances is permitted solely under the conditions 163 | stated below. Sublicensing is not allowed; section 10 makes it unnecessary. 164 | 165 | ### 3. Protecting Users' Legal Rights From Anti-Circumvention Law. 166 | 167 | No covered work shall be deemed part of an effective technological measure under any 168 | applicable law fulfilling obligations under article 11 of the WIPO copyright treaty 169 | adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention 170 | of such measures. 171 | 172 | When you convey a covered work, you waive any legal power to forbid circumvention of 173 | technological measures to the extent such circumvention is effected by exercising 174 | rights under this License with respect to the covered work, and you disclaim any 175 | intention to limit operation or modification of the work as a means of enforcing, 176 | against the work's users, your or third parties' legal rights to forbid circumvention 177 | of technological measures. 178 | 179 | ### 4. Conveying Verbatim Copies. 180 | 181 | You may convey verbatim copies of the Program's source code as you receive it, in any 182 | medium, provided that you conspicuously and appropriately publish on each copy an 183 | appropriate copyright notice; keep intact all notices stating that this License and 184 | any non-permissive terms added in accord with section 7 apply to the code; keep 185 | intact all notices of the absence of any warranty; and give all recipients a copy of 186 | this License along with the Program. 187 | 188 | You may charge any price or no price for each copy that you convey, and you may offer 189 | support or warranty protection for a fee. 190 | 191 | ### 5. Conveying Modified Source Versions. 192 | 193 | You may convey a work based on the Program, or the modifications to produce it from 194 | the Program, in the form of source code under the terms of section 4, provided that 195 | you also meet all of these conditions: 196 | 197 | * **a)** The work must carry prominent notices stating that you modified it, and giving a 198 | relevant date. 199 | * **b)** The work must carry prominent notices stating that it is released under this 200 | License and any conditions added under section 7. This requirement modifies the 201 | requirement in section 4 to “keep intact all notices”. 202 | * **c)** You must license the entire work, as a whole, under this License to anyone who 203 | comes into possession of a copy. This License will therefore apply, along with any 204 | applicable section 7 additional terms, to the whole of the work, and all its parts, 205 | regardless of how they are packaged. This License gives no permission to license the 206 | work in any other way, but it does not invalidate such permission if you have 207 | separately received it. 208 | * **d)** If the work has interactive user interfaces, each must display Appropriate Legal 209 | Notices; however, if the Program has interactive interfaces that do not display 210 | Appropriate Legal Notices, your work need not make them do so. 211 | 212 | A compilation of a covered work with other separate and independent works, which are 213 | not by their nature extensions of the covered work, and which are not combined with 214 | it such as to form a larger program, in or on a volume of a storage or distribution 215 | medium, is called an “aggregate” if the compilation and its resulting 216 | copyright are not used to limit the access or legal rights of the compilation's users 217 | beyond what the individual works permit. Inclusion of a covered work in an aggregate 218 | does not cause this License to apply to the other parts of the aggregate. 219 | 220 | ### 6. Conveying Non-Source Forms. 221 | 222 | You may convey a covered work in object code form under the terms of sections 4 and 223 | 5, provided that you also convey the machine-readable Corresponding Source under the 224 | terms of this License, in one of these ways: 225 | 226 | * **a)** Convey the object code in, or embodied in, a physical product (including a 227 | physical distribution medium), accompanied by the Corresponding Source fixed on a 228 | durable physical medium customarily used for software interchange. 229 | * **b)** Convey the object code in, or embodied in, a physical product (including a 230 | physical distribution medium), accompanied by a written offer, valid for at least 231 | three years and valid for as long as you offer spare parts or customer support for 232 | that product model, to give anyone who possesses the object code either (1) a copy of 233 | the Corresponding Source for all the software in the product that is covered by this 234 | License, on a durable physical medium customarily used for software interchange, for 235 | a price no more than your reasonable cost of physically performing this conveying of 236 | source, or (2) access to copy the Corresponding Source from a network server at no 237 | charge. 238 | * **c)** Convey individual copies of the object code with a copy of the written offer to 239 | provide the Corresponding Source. This alternative is allowed only occasionally and 240 | noncommercially, and only if you received the object code with such an offer, in 241 | accord with subsection 6b. 242 | * **d)** Convey the object code by offering access from a designated place (gratis or for 243 | a charge), and offer equivalent access to the Corresponding Source in the same way 244 | through the same place at no further charge. You need not require recipients to copy 245 | the Corresponding Source along with the object code. If the place to copy the object 246 | code is a network server, the Corresponding Source may be on a different server 247 | (operated by you or a third party) that supports equivalent copying facilities, 248 | provided you maintain clear directions next to the object code saying where to find 249 | the Corresponding Source. Regardless of what server hosts the Corresponding Source, 250 | you remain obligated to ensure that it is available for as long as needed to satisfy 251 | these requirements. 252 | * **e)** Convey the object code using peer-to-peer transmission, provided you inform 253 | other peers where the object code and Corresponding Source of the work are being 254 | offered to the general public at no charge under subsection 6d. 255 | 256 | A separable portion of the object code, whose source code is excluded from the 257 | Corresponding Source as a System Library, need not be included in conveying the 258 | object code work. 259 | 260 | A “User Product” is either (1) a “consumer product”, which 261 | means any tangible personal property which is normally used for personal, family, or 262 | household purposes, or (2) anything designed or sold for incorporation into a 263 | dwelling. In determining whether a product is a consumer product, doubtful cases 264 | shall be resolved in favor of coverage. For a particular product received by a 265 | particular user, “normally used” refers to a typical or common use of 266 | that class of product, regardless of the status of the particular user or of the way 267 | in which the particular user actually uses, or expects or is expected to use, the 268 | product. A product is a consumer product regardless of whether the product has 269 | substantial commercial, industrial or non-consumer uses, unless such uses represent 270 | the only significant mode of use of the product. 271 | 272 | “Installation Information” for a User Product means any methods, 273 | procedures, authorization keys, or other information required to install and execute 274 | modified versions of a covered work in that User Product from a modified version of 275 | its Corresponding Source. The information must suffice to ensure that the continued 276 | functioning of the modified object code is in no case prevented or interfered with 277 | solely because modification has been made. 278 | 279 | If you convey an object code work under this section in, or with, or specifically for 280 | use in, a User Product, and the conveying occurs as part of a transaction in which 281 | the right of possession and use of the User Product is transferred to the recipient 282 | in perpetuity or for a fixed term (regardless of how the transaction is 283 | characterized), the Corresponding Source conveyed under this section must be 284 | accompanied by the Installation Information. But this requirement does not apply if 285 | neither you nor any third party retains the ability to install modified object code 286 | on the User Product (for example, the work has been installed in ROM). 287 | 288 | The requirement to provide Installation Information does not include a requirement to 289 | continue to provide support service, warranty, or updates for a work that has been 290 | modified or installed by the recipient, or for the User Product in which it has been 291 | modified or installed. Access to a network may be denied when the modification itself 292 | materially and adversely affects the operation of the network or violates the rules 293 | and protocols for communication across the network. 294 | 295 | Corresponding Source conveyed, and Installation Information provided, in accord with 296 | this section must be in a format that is publicly documented (and with an 297 | implementation available to the public in source code form), and must require no 298 | special password or key for unpacking, reading or copying. 299 | 300 | ### 7. Additional Terms. 301 | 302 | “Additional permissions” are terms that supplement the terms of this 303 | License by making exceptions from one or more of its conditions. Additional 304 | permissions that are applicable to the entire Program shall be treated as though they 305 | were included in this License, to the extent that they are valid under applicable 306 | law. If additional permissions apply only to part of the Program, that part may be 307 | used separately under those permissions, but the entire Program remains governed by 308 | this License without regard to the additional permissions. 309 | 310 | When you convey a copy of a covered work, you may at your option remove any 311 | additional permissions from that copy, or from any part of it. (Additional 312 | permissions may be written to require their own removal in certain cases when you 313 | modify the work.) You may place additional permissions on material, added by you to a 314 | covered work, for which you have or can give appropriate copyright permission. 315 | 316 | Notwithstanding any other provision of this License, for material you add to a 317 | covered work, you may (if authorized by the copyright holders of that material) 318 | supplement the terms of this License with terms: 319 | 320 | * **a)** Disclaiming warranty or limiting liability differently from the terms of 321 | sections 15 and 16 of this License; or 322 | * **b)** Requiring preservation of specified reasonable legal notices or author 323 | attributions in that material or in the Appropriate Legal Notices displayed by works 324 | containing it; or 325 | * **c)** Prohibiting misrepresentation of the origin of that material, or requiring that 326 | modified versions of such material be marked in reasonable ways as different from the 327 | original version; or 328 | * **d)** Limiting the use for publicity purposes of names of licensors or authors of the 329 | material; or 330 | * **e)** Declining to grant rights under trademark law for use of some trade names, 331 | trademarks, or service marks; or 332 | * **f)** Requiring indemnification of licensors and authors of that material by anyone 333 | who conveys the material (or modified versions of it) with contractual assumptions of 334 | liability to the recipient, for any liability that these contractual assumptions 335 | directly impose on those licensors and authors. 336 | 337 | All other non-permissive additional terms are considered “further 338 | restrictions” within the meaning of section 10. If the Program as you received 339 | it, or any part of it, contains a notice stating that it is governed by this License 340 | along with a term that is a further restriction, you may remove that term. If a 341 | license document contains a further restriction but permits relicensing or conveying 342 | under this License, you may add to a covered work material governed by the terms of 343 | that license document, provided that the further restriction does not survive such 344 | relicensing or conveying. 345 | 346 | If you add terms to a covered work in accord with this section, you must place, in 347 | the relevant source files, a statement of the additional terms that apply to those 348 | files, or a notice indicating where to find the applicable terms. 349 | 350 | Additional terms, permissive or non-permissive, may be stated in the form of a 351 | separately written license, or stated as exceptions; the above requirements apply 352 | either way. 353 | 354 | ### 8. Termination. 355 | 356 | You may not propagate or modify a covered work except as expressly provided under 357 | this License. Any attempt otherwise to propagate or modify it is void, and will 358 | automatically terminate your rights under this License (including any patent licenses 359 | granted under the third paragraph of section 11). 360 | 361 | However, if you cease all violation of this License, then your license from a 362 | particular copyright holder is reinstated (a) provisionally, unless and until the 363 | copyright holder explicitly and finally terminates your license, and (b) permanently, 364 | if the copyright holder fails to notify you of the violation by some reasonable means 365 | prior to 60 days after the cessation. 366 | 367 | Moreover, your license from a particular copyright holder is reinstated permanently 368 | if the copyright holder notifies you of the violation by some reasonable means, this 369 | is the first time you have received notice of violation of this License (for any 370 | work) from that copyright holder, and you cure the violation prior to 30 days after 371 | your receipt of the notice. 372 | 373 | Termination of your rights under this section does not terminate the licenses of 374 | parties who have received copies or rights from you under this License. If your 375 | rights have been terminated and not permanently reinstated, you do not qualify to 376 | receive new licenses for the same material under section 10. 377 | 378 | ### 9. Acceptance Not Required for Having Copies. 379 | 380 | You are not required to accept this License in order to receive or run a copy of the 381 | Program. Ancillary propagation of a covered work occurring solely as a consequence of 382 | using peer-to-peer transmission to receive a copy likewise does not require 383 | acceptance. However, nothing other than this License grants you permission to 384 | propagate or modify any covered work. These actions infringe copyright if you do not 385 | accept this License. Therefore, by modifying or propagating a covered work, you 386 | indicate your acceptance of this License to do so. 387 | 388 | ### 10. Automatic Licensing of Downstream Recipients. 389 | 390 | Each time you convey a covered work, the recipient automatically receives a license 391 | from the original licensors, to run, modify and propagate that work, subject to this 392 | License. You are not responsible for enforcing compliance by third parties with this 393 | License. 394 | 395 | An “entity transaction” is a transaction transferring control of an 396 | organization, or substantially all assets of one, or subdividing an organization, or 397 | merging organizations. If propagation of a covered work results from an entity 398 | transaction, each party to that transaction who receives a copy of the work also 399 | receives whatever licenses to the work the party's predecessor in interest had or 400 | could give under the previous paragraph, plus a right to possession of the 401 | Corresponding Source of the work from the predecessor in interest, if the predecessor 402 | has it or can get it with reasonable efforts. 403 | 404 | You may not impose any further restrictions on the exercise of the rights granted or 405 | affirmed under this License. For example, you may not impose a license fee, royalty, 406 | or other charge for exercise of rights granted under this License, and you may not 407 | initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging 408 | that any patent claim is infringed by making, using, selling, offering for sale, or 409 | importing the Program or any portion of it. 410 | 411 | ### 11. Patents. 412 | 413 | A “contributor” is a copyright holder who authorizes use under this 414 | License of the Program or a work on which the Program is based. The work thus 415 | licensed is called the contributor's “contributor version”. 416 | 417 | A contributor's “essential patent claims” are all patent claims owned or 418 | controlled by the contributor, whether already acquired or hereafter acquired, that 419 | would be infringed by some manner, permitted by this License, of making, using, or 420 | selling its contributor version, but do not include claims that would be infringed 421 | only as a consequence of further modification of the contributor version. For 422 | purposes of this definition, “control” includes the right to grant patent 423 | sublicenses in a manner consistent with the requirements of this License. 424 | 425 | Each contributor grants you a non-exclusive, worldwide, royalty-free patent license 426 | under the contributor's essential patent claims, to make, use, sell, offer for sale, 427 | import and otherwise run, modify and propagate the contents of its contributor 428 | version. 429 | 430 | In the following three paragraphs, a “patent license” is any express 431 | agreement or commitment, however denominated, not to enforce a patent (such as an 432 | express permission to practice a patent or covenant not to sue for patent 433 | infringement). To “grant” such a patent license to a party means to make 434 | such an agreement or commitment not to enforce a patent against the party. 435 | 436 | If you convey a covered work, knowingly relying on a patent license, and the 437 | Corresponding Source of the work is not available for anyone to copy, free of charge 438 | and under the terms of this License, through a publicly available network server or 439 | other readily accessible means, then you must either (1) cause the Corresponding 440 | Source to be so available, or (2) arrange to deprive yourself of the benefit of the 441 | patent license for this particular work, or (3) arrange, in a manner consistent with 442 | the requirements of this License, to extend the patent license to downstream 443 | recipients. “Knowingly relying” means you have actual knowledge that, but 444 | for the patent license, your conveying the covered work in a country, or your 445 | recipient's use of the covered work in a country, would infringe one or more 446 | identifiable patents in that country that you have reason to believe are valid. 447 | 448 | If, pursuant to or in connection with a single transaction or arrangement, you 449 | convey, or propagate by procuring conveyance of, a covered work, and grant a patent 450 | license to some of the parties receiving the covered work authorizing them to use, 451 | propagate, modify or convey a specific copy of the covered work, then the patent 452 | license you grant is automatically extended to all recipients of the covered work and 453 | works based on it. 454 | 455 | A patent license is “discriminatory” if it does not include within the 456 | scope of its coverage, prohibits the exercise of, or is conditioned on the 457 | non-exercise of one or more of the rights that are specifically granted under this 458 | License. You may not convey a covered work if you are a party to an arrangement with 459 | a third party that is in the business of distributing software, under which you make 460 | payment to the third party based on the extent of your activity of conveying the 461 | work, and under which the third party grants, to any of the parties who would receive 462 | the covered work from you, a discriminatory patent license (a) in connection with 463 | copies of the covered work conveyed by you (or copies made from those copies), or (b) 464 | primarily for and in connection with specific products or compilations that contain 465 | the covered work, unless you entered into that arrangement, or that patent license 466 | was granted, prior to 28 March 2007. 467 | 468 | Nothing in this License shall be construed as excluding or limiting any implied 469 | license or other defenses to infringement that may otherwise be available to you 470 | under applicable patent law. 471 | 472 | ### 12. No Surrender of Others' Freedom. 473 | 474 | If conditions are imposed on you (whether by court order, agreement or otherwise) 475 | that contradict the conditions of this License, they do not excuse you from the 476 | conditions of this License. If you cannot convey a covered work so as to satisfy 477 | simultaneously your obligations under this License and any other pertinent 478 | obligations, then as a consequence you may not convey it at all. For example, if you 479 | agree to terms that obligate you to collect a royalty for further conveying from 480 | those to whom you convey the Program, the only way you could satisfy both those terms 481 | and this License would be to refrain entirely from conveying the Program. 482 | 483 | ### 13. Use with the GNU Affero General Public License. 484 | 485 | Notwithstanding any other provision of this License, you have permission to link or 486 | combine any covered work with a work licensed under version 3 of the GNU Affero 487 | General Public License into a single combined work, and to convey the resulting work. 488 | The terms of this License will continue to apply to the part which is the covered 489 | work, but the special requirements of the GNU Affero General Public License, section 490 | 13, concerning interaction through a network will apply to the combination as such. 491 | 492 | ### 14. Revised Versions of this License. 493 | 494 | The Free Software Foundation may publish revised and/or new versions of the GNU 495 | General Public License from time to time. Such new versions will be similar in spirit 496 | to the present version, but may differ in detail to address new problems or concerns. 497 | 498 | Each version is given a distinguishing version number. If the Program specifies that 499 | a certain numbered version of the GNU General Public License “or any later 500 | version” applies to it, you have the option of following the terms and 501 | conditions either of that numbered version or of any later version published by the 502 | Free Software Foundation. If the Program does not specify a version number of the GNU 503 | General Public License, you may choose any version ever published by the Free 504 | Software Foundation. 505 | 506 | If the Program specifies that a proxy can decide which future versions of the GNU 507 | General Public License can be used, that proxy's public statement of acceptance of a 508 | version permanently authorizes you to choose that version for the Program. 509 | 510 | Later license versions may give you additional or different permissions. However, no 511 | additional obligations are imposed on any author or copyright holder as a result of 512 | your choosing to follow a later version. 513 | 514 | ### 15. Disclaimer of Warranty. 515 | 516 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. 517 | EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES 518 | PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER 519 | EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 520 | MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE 521 | QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE 522 | DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 523 | 524 | ### 16. Limitation of Liability. 525 | 526 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY 527 | COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS 528 | PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, 529 | INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE 530 | PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE 531 | OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE 532 | WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE 533 | POSSIBILITY OF SUCH DAMAGES. 534 | 535 | ### 17. Interpretation of Sections 15 and 16. 536 | 537 | If the disclaimer of warranty and limitation of liability provided above cannot be 538 | given local legal effect according to their terms, reviewing courts shall apply local 539 | law that most closely approximates an absolute waiver of all civil liability in 540 | connection with the Program, unless a warranty or assumption of liability accompanies 541 | a copy of the Program in return for a fee. 542 | 543 | END OF TERMS AND CONDITIONS 544 | 545 | ## How to Apply These Terms to Your New Programs 546 | 547 | If you develop a new program, and you want it to be of the greatest possible use to 548 | the public, the best way to achieve this is to make it free software which everyone 549 | can redistribute and change under these terms. 550 | 551 | To do so, attach the following notices to the program. It is safest to attach them 552 | to the start of each source file to most effectively state the exclusion of warranty; 553 | and each file should have at least the “copyright” line and a pointer to 554 | where the full notice is found. 555 | 556 | 557 | Copyright (C) 558 | 559 | This program is free software: you can redistribute it and/or modify 560 | it under the terms of the GNU General Public License as published by 561 | the Free Software Foundation, either version 3 of the License, or 562 | (at your option) any later version. 563 | 564 | This program is distributed in the hope that it will be useful, 565 | but WITHOUT ANY WARRANTY; without even the implied warranty of 566 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 567 | GNU General Public License for more details. 568 | 569 | You should have received a copy of the GNU General Public License 570 | along with this program. If not, see . 571 | 572 | Also add information on how to contact you by electronic and paper mail. 573 | 574 | If the program does terminal interaction, make it output a short notice like this 575 | when it starts in an interactive mode: 576 | 577 | Copyright (C) 578 | This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'. 579 | This is free software, and you are welcome to redistribute it 580 | under certain conditions; type 'show c' for details. 581 | 582 | The hypothetical commands 'show w' and 'show c' should show the appropriate parts of 583 | the General Public License. Of course, your program's commands might be different; 584 | for a GUI interface, you would use an “about box”. 585 | 586 | You should also get your employer (if you work as a programmer) or school, if any, to 587 | sign a “copyright disclaimer” for the program, if necessary. For more 588 | information on this, and how to apply and follow the GNU GPL, see 589 | <>. 590 | 591 | The GNU General Public License does not permit incorporating your program into 592 | proprietary programs. If your program is a subroutine library, you may consider it 593 | more useful to permit linking proprietary applications with the library. If this is 594 | what you want to do, use the GNU Lesser General Public License instead of this 595 | License. But first, please read 596 | <>. 597 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # 中国象棋 Python | Chinese Chess Python 2 | 3 | ## 特性 4 | - 代码简洁：仅仅使用一百多行代码即实现了中国象棋，并具有简单对战功能。 5 | - 性能高效：经测试水平在初学者之上。 6 | - 使用传统象棋表示方法来表示棋子移动。 7 | 8 | ## 缺点 9 | - 现代竞技象棋有许多复杂的规则，例如不得长将，长吃等，参见[2011版象棋规则](http://www.xqbase.com/protocol/rule2011.pdf)。本程序仅实现了基本规则，未实现禁手。 10 | - 没有引入随机参数，导致在相同局面下程序总是会有相同的输出。 11 | 12 | ## 注意 13 | - 本程序使用的象棋棋子来自Unicode13中的[棋类符号](https://www.unicode.org/charts/PDF/U1FA00.pdf)，如果你的电脑能正确显示以下几个字符：🩠 🩡 🩢 🩣 🩤 🩦 🩥 🩧 🩨 🩩 🩪 🩫 🩭 🩬，则可以最大程度上利用本程序，否则请在运行程序时设定棋子编码参数`p/piece`为`chinese`，即`python xiangqi.py -p chinese`或`python xiangqi.py --piece chinese`。 14 | - 因为字体关系，有些字体中文字符长度不等于两个英文字符长度，所以显示的棋盘可能没有对其，可以通过设定宽度参数`w/width`来进行调节，即`python xiangqi.py -w 2`或`python xiangqi.py --width 2`。 15 | - 测试运行环境为Ubuntu20.04，使用系统terminal，字体为Monospace Regular。 16 | 17 | ## 运行截图 18 | 19 | ![xiangqi_unicode](screenshot/xiangqi_unicode.png) 20 | 21 | 如果添加设置参数`--pieces chinese` 22 | 23 | ![xaingqi_chinese](screenshot/xiangqi_chinese.png) 24 | 25 | # 运行程序 26 | ```shell 27 | python xiangqi.py -p unicode -w 1 28 | ``` 29 | 30 | ## 棋盘显示 31 | 本仓库代码还实现了中文棋盘显示，运行`python draw_board.py`即可。同样，如果字体不支持Unicode13， 可修改`draw_board.py`第一行为`def chinese_chess(mode=''):`。效果如下所示： 32 | 33 | 如果字体支持Unicode13 34 | 35 | ![draw_board](screenshot/chess_board_unicode.png) 36 | 37 | 如果不支持Unicode13 38 | 39 | ![draw_board](screenshot/chess_board_chinese.png) 40 | 41 | ## 参考资料 42 | `xiangqi.py`: 43 | - 算法及代码部分，主要借鉴[sunfish](https://github.com/thomasahle/sunfish) 44 | - 算法原理介绍：[MTD(f)算法](http://www.soongsky.com/othello/computer/alpha_beta.php) 45 | - 子力价值判断及局面判断权重，主要使用了[Computer Chinese Chess](http://www.psung.org/xq/computer/2004CCC.pdf) 46 | 47 | `draw_board.y`: 48 | - 棋盘绘制，主要参考[Unicode chessboard in a terminal](https://www.daniweb.com/programming/software-development/code/423640/unicode-chessboard-in-a-terminal) 49 | - FEN格式串介绍：[象棋百科全书](https://www.xqbase.com/protocol.htm) -------------------------------------------------------------------------------- /draw_board.py: -------------------------------------------------------------------------------- 1 | def chinese_chess(mode='unicode'): 2 | pieces_chinese = '帅仕相马车炮兵将士象馬車砲卒' 3 | pieces_unicode = U''.join(chr(0x1FA60 + i) for i in range(14)) 4 | # king advisor elephant rook cannon horse pawn 5 | pieces_fen = 'KAEHRCPkaehrcp' 6 | if mode == 'unicode': 7 | pieces = pieces_unicode 8 | else: 9 | pieces = pieces_chinese 10 | fen_map = dict(zip(pieces_fen, pieces)) 11 | fen_start = 'rheakaehr/9/1c5c1/p1p1p1p1p/9/9/P1P1P1P1P/1C5C1/9/RHEAKAEHR w - - 0 1' 12 | 13 | box = u''.join(chr(9472 + x) for x in (2, 0, 12, 16, 20, 24, 44, 52, 28, 36, 60)) 14 | vbar, hbar, ul, ur, ll, lr, nt, st, wt, et, plus = box 15 | # │ ─ ┌ ┐ └ ┘ ┬ ┴ ├ ┤ ┼ 16 | ls, rs = '\uff3c', '\uff0f' 17 | # ／ ＼ 18 | h3 = hbar * 3 19 | h2 = hbar * 2 20 | # useful constant unicode strings to draw the square borders 21 | inter = (vbar + ' ') * 8 + vbar 22 | topline = [ul, *[nt] * 7, ur] 23 | midline = [wt, *[plus] * 7, et] 24 | rivertop = [wt, *[st] * 7, et] 25 | riverline = [vbar, '楚', '河', ' ', '汉', '界', vbar] 26 | riverdown = [wt, *[nt] * 7, et] 27 | blackline = [vbar] * 9 28 | topblackline = [vbar, ' '] * 3 + [vbar, ' ', ls, vbar, rs, ' ', vbar] + [' ', vbar] * 3 29 | canonblackline = [vbar, ' '] * 3 + [vbar, ' ', rs, vbar, ls, ' ', vbar] + [' ', vbar] * 3 30 | bottomline = [ll, *[st] * 7, lr] 31 | 32 | def fill(line: list, fen_string: str): 33 | """Return a unicode string with a line of the chessboard. 34 | """ 35 | line_copy = line[:] 36 | h_list = [] 37 | index = 0 38 | for char in fen_string: 39 | if char.isnumeric(): 40 | index += int(char) 41 | h_list.extend([h3] * int(char)) 42 | else: 43 | line_copy[index] = fen_map[char] 44 | index += 1 45 | if mode == 'unicode': 46 | h_list.append(' ' + h2) 47 | else: 48 | h_list.append(h2) 49 | result = '' 50 | h_list[-1] = '' 51 | for char, h in zip(line_copy, h_list): 52 | result += char + h 53 | return result 54 | 55 | def _game(fen_line): 56 | for i, fen in enumerate(fen_line.split()[0].split('/')): 57 | if i == 0: 58 | line = topline 59 | elif i == 9: 60 | line = bottomline 61 | elif i == 4: 62 | line = rivertop 63 | elif i == 5: 64 | line = riverdown 65 | else: 66 | line = midline 67 | yield fill(line, fen) 68 | if i == 0 or i == 7: 69 | yield ''.join(topblackline) 70 | elif i == 1 or i == 8: 71 | yield ''.join(canonblackline) 72 | elif i == 4: 73 | yield ' '.join(riverline) 74 | elif i < 9: 75 | yield ' '.join(blackline) 76 | 77 | game = lambda squares: "\n".join(_game(squares)) 78 | game.__doc__ = """Return the chessboard as a string for a given position. 79 | position is a list of 8 lists or tuples of length 8 containing integers 80 | """ 81 | return game(fen_start) 82 | 83 | 84 | def chess(): 85 | pieces = u''.join(chr(9812 + x) for x in range(12)) 86 | pieces = u' ' + pieces[:6][::-1] + pieces[6:] 87 | box = u''.join(chr(9472 + x) for x in (2, 0, 12, 16, 20, 24, 44, 52, 28, 36, 60)) 88 | vbar, hbar, ul, ur, ll, lr, nt, st, wt, et, plus = box 89 | # │ ─ ┌ ┐ └ ┘ ┬ ┴ ├ ┤ ┼ 90 | h3 = hbar * 3 91 | # useful constant unicode strings to draw the square borders 92 | topline = ul + (h3 + nt) * 7 + h3 + ur 93 | midline = wt + (h3 + plus) * 7 + h3 + et 94 | botline = ll + (h3 + st) * 7 + h3 + lr 95 | tpl = u' {0} ' + vbar 96 | 97 | def inter(*args): 98 | """Return a unicode string with a line of the chessboard. 99 | 100 | args are 8 integers with the values 101 | 0 : empty square 102 | 1, 2, 3, 4, 5, 6: white pawn, knight, bishop, rook, queen, king 103 | -1, -2, -3, -4, -5, -6: same black pieces 104 | """ 105 | assert len(args) == 8 106 | return vbar + u''.join((tpl.format(pieces[a]) for a in args)) 107 | 108 | print(pieces) 109 | print(' '.join(box)) 110 | start_position = ( 111 | [ 112 | (-4, -2, -3, -5, -6, -3, -2, -4), 113 | (-1,) * 8, 114 | ] + 115 | [(0,) * 8] * 4 + 116 | [ 117 | (1,) * 8, 118 | (4, 2, 3, 5, 6, 3, 2, 4), 119 | ] 120 | ) 121 | 122 | def _game(position): 123 | yield topline 124 | yield inter(*position[0]) 125 | for row in position[1:]: 126 | yield midline 127 | yield inter(*row) 128 | yield botline 129 | 130 | game = lambda squares: "\n".join(_game(squares)) 131 | game.__doc__ = """Return the chessboard as a string for a given position. 132 | position is a list of 8 lists or tuples of length 8 containing integers 133 | """ 134 | return game(start_position) 135 | 136 | 137 | if __name__ == "__main__": 138 | print(chinese_chess()) 139 | -------------------------------------------------------------------------------- /screenshot/chess_board_chinese.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/techkang/xiangqi/c2a7d94d5cb2e7ebd5e70b631783da3f8a8e9066/screenshot/chess_board_chinese.png -------------------------------------------------------------------------------- /screenshot/chess_board_unicode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/techkang/xiangqi/c2a7d94d5cb2e7ebd5e70b631783da3f8a8e9066/screenshot/chess_board_unicode.png -------------------------------------------------------------------------------- /screenshot/xiangqi_chinese.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/techkang/xiangqi/c2a7d94d5cb2e7ebd5e70b631783da3f8a8e9066/screenshot/xiangqi_chinese.png -------------------------------------------------------------------------------- /screenshot/xiangqi_unicode.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/techkang/xiangqi/c2a7d94d5cb2e7ebd5e70b631783da3f8a8e9066/screenshot/xiangqi_unicode.png -------------------------------------------------------------------------------- /xiangqi.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # -*- coding: utf-8 -*- 3 | 4 | import argparse 5 | import re 6 | import time 7 | from collections import namedtuple 8 | from itertools import count 9 | 10 | ############################################################################### 11 | # Piece-Square tables. Tune these to change sunfish's behaviour 12 | ############################################################################### 13 | uni_pieces = {'R': '🩤', 'H': '🩣', 'E': '🩢', 'A': '🩡', 'K': '🩠', 'C': '🩥', 'P': '🩦', 14 | 'r': '🩫', 'h': '🩪', 'e': '🩩', 'a': '🩨', 'k': '🩧', 'c': '🩬', 'p': '🩭', '.': '·'} 15 | chinese_pieces = {'R': '车', 'H': '马', 'E': '相', 'A': '仕', 'K': '帅', 'C': '炮', 'P': '兵', 16 | 'r': '車', 'h': '马', 'e': '象', 'a': '士', 'k': '将', 'c': '砲', 'p': '卒', '.': '· '} 17 | 18 | CHESS_ROW = 10 19 | CHESS_COLUMN = 9 20 | BOARD_ROW = CHESS_ROW+4 21 | BOARD_COLUMN = CHESS_COLUMN+2 22 | # king, advisor, elephant, horse, rook, pawn, cannon 23 | piece = {'K': 6000, 'A': 120, 'E': 120, 'H': 270, 'R': 600, 'P': 30, 'C': 285} 24 | pst = { 25 | 'K': ( 26 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 27 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 28 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 29 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 30 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 31 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 32 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 33 | 0, 0, 0, -9, -9, -9, 0, 0, 0, 34 | 0, 0, 0, -8, -8, -8, 0, 0, 0, 35 | 0, 0, 0, 1, 5, 1, 0, 0, 0, 36 | ), 37 | 'A': ( 38 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 39 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 40 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 41 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 42 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 43 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 44 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 45 | 0, 0, 0, -1, 0, -1, 0, 0, 0, 46 | 0, 0, 0, 0, 3, 0, 0, 0, 0, 47 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 48 | ), 49 | 'E': ( 50 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 51 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 52 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 53 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 54 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 55 | 0, 0, -1, 0, 0, 0, -1, 0, 0, 56 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 57 | -2, 0, 0, 0, 3, 0, 0, 0, -2, 58 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 59 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 60 | ), 61 | 'H': ( 62 | 4, 8, 16, 12, 4, 12, 16, 8, 4, 63 | 4, 10, 28, 16, 8, 16, 28, 10, 4, 64 | 12, 14, 16, 20, 18, 20, 16, 14, 12, 65 | 8, 24, 18, 24, 20, 24, 18, 24, 8, 66 | 6, 16, 14, 18, 16, 18, 14, 16, 6, 67 | 4, 12, 16, 14, 12, 14, 16, 12, 4, 68 | 2, 6, 8, 6, 10, 6, 8, 6, 2, 69 | 4, 2, 8, 8, 6, 8, 8, 2, 4, 70 | 0, 2, 4, 4, -10, 4, 4, 2, 0, 71 | 0, -4, 0, 0, 0, 0, 0, -4, 0, 72 | 73 | ), 74 | 'R': ( 75 | 14, 14, 12, 18, 16, 18, 12, 14, 14, 76 | 16, 20, 18, 24, 26, 24, 18, 20, 16, 77 | 12, 12, 12, 18, 18, 18, 12, 12, 12, 78 | 12, 18, 16, 22, 22, 22, 16, 18, 12, 79 | 12, 14, 12, 18, 18, 18, 12, 14, 12, 80 | 12, 16, 14, 20, 20, 20, 14, 16, 12, 81 | 6, 10, 8, 14, 14, 14, 8, 10, 6, 82 | 4, 8, 6, 14, 12, 14, 6, 8, 4, 83 | 8, 4, 8, 16, 8, 16, 8, 4, 8, 84 | -2, 10, 6, 14, 12, 14, 6, 10, -2, 85 | ), 86 | 'C': ( 87 | 6, 4, 0, -10, -12, -10, 0, 4, 6, 88 | 2, 2, 0, -4, -14, -4, 0, 2, 2, 89 | 2, 2, 0, -10, -8, -10, 0, 2, 2, 90 | 0, 0, -2, 4, 10, 4, -2, 0, 0, 91 | 0, 0, 0, 2, 8, 2, 0, 0, 0, 92 | -2, 0, 4, 2, 6, 2, 4, 0, -2, 93 | 0, 0, 0, 2, 4, 2, 0, 0, 0, 94 | 4, 0, 8, 6, 19, 6, 8, 0, 4, 95 | 0, 2, 4, 6, 6, 6, 4, 2, 0, 96 | 0, 0, 2, 6, 6, 6, 2, 0, 0, 97 | ), 98 | 'P': ( 99 | 0, 3, 6, 9, 12, 9, 6, 3, 0, 100 | 18, 36, 56, 80, 120, 80, 56, 36, 18, 101 | 14, 26, 42, 60, 80, 60, 42, 26, 14, 102 | 10, 20, 30, 34, 40, 34, 30, 20, 10, 103 | 6, 12, 18, 18, 20, 18, 18, 12, 6, 104 | 2, 0, 8, 0, 8, 0, 8, 0, 2, 105 | 0, 0, -2, 0, 4, 0, -2, 0, 0, 106 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 107 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 108 | 0, 0, 0, 0, 0, 0, 0, 0, 0, 109 | ) 110 | } 111 | 112 | 113 | def padrow(row): 114 | result = (0,) + tuple(x + piece[k] for x in row) + (0,) 115 | return result 116 | 117 | 118 | # Pad tables and join piece and pst dictionaries 119 | for k, table in pst.items(): 120 | pst[k] = sum((padrow(table[i * CHESS_COLUMN:(i+1)*CHESS_COLUMN]) 121 | for i in range(CHESS_ROW)), ()) 122 | pst[k] = (0,) * 22 + pst[k] + (0,) * 22 123 | pst[k] = pst[k] 124 | 125 | ############################################################################### 126 | # Global constants 127 | ############################################################################### 128 | 129 | # Our board is represented as a 120 character string. The padding allows for 130 | # fast detection of moves that don't stay within the board. 131 | initial = ( 132 | ' \n' 133 | ' \n' 134 | ' rheakaehr\n' 135 | ' .........\n' 136 | ' .c.....c.\n' 137 | ' p.p.p.p.p\n' 138 | ' .........\n' 139 | # river 140 | ' .........\n' 141 | ' P.P.P.P.P\n' 142 | ' .C.....C.\n' 143 | ' .........\n' 144 | ' RHEAKAEHR\n' 145 | ' \n' 146 | ' \n' 147 | ) 148 | 149 | # Lists of possible moves for each piece type. 150 | N, E, S, W = -BOARD_COLUMN, 1, BOARD_COLUMN, -1 151 | directions = { 152 | 'P': (N, W, E), 153 | 'H': ((N, N + E), (N, N + W), (S, S + E), (S, S + W), (E, E + N), (E, E + S), (W, W + N), (W, W + S)), 154 | 'E': ((N + E, N + E), (S + E, S + E), (S + W, S + W), (N + W, N + W)), 155 | 'A': (N + E, S + E, S + W, N + W), 156 | 'R': (N, E, S, W), 157 | 'C': (N, E, S, W), 158 | 'K': (N, E, S, W) 159 | } 160 | 161 | # Mate value must be greater than all the other values 162 | # King value is set to twice this value such that if the opponent is 163 | # 8 queens up, but we got the king, we still exceed MATE_VALUE. 164 | # When a MATE is detected, we'll set the score to MATE_UPPER - plies to get there 165 | # E.g. Mate in 3 will be MATE_UPPER - 6 166 | MATE_LOWER = piece['K'] - 2 * (piece['R'] + piece['H'] + 167 | piece['C'] + piece['A'] + piece['E'] + 2.5 * piece['P']) 168 | MATE_UPPER = piece['K'] + 2 * (piece['R'] + piece['H'] + 169 | piece['C'] + piece['A'] + piece['E'] + 2.5 * piece['P']) 170 | 171 | # The table size is the maximum number of elements in the transposition table. 172 | TABLE_SIZE = 1e7 173 | 174 | # Constants for tuning search 175 | QS_LIMIT = 219 176 | EVAL_ROUGHNESS = 13 177 | DRAW_TEST = True 178 | 179 | 180 | ############################################################################### 181 | # Chess logic 182 | ############################################################################### 183 | 184 | class Position(namedtuple('Position', 'board score')): 185 | """ A state of a chess game 186 | board -- a BOARD_ROW*BOARD_COLUMN char representation of the board 187 | score -- the board evaluation 188 | """ 189 | 190 | def gen_moves(self): 191 | # For each of our pieces, iterate through each possible 'ray' of moves, 192 | # as defined in the 'directions' map. The rays are broken e.g. by 193 | # captures or immediately in case of pieces such as horse. 194 | for i, p in enumerate(self.board): 195 | if not p.isupper(): 196 | continue 197 | for d in directions[p]: 198 | cannon_flag = False 199 | step = 0 200 | if isinstance(d, tuple): 201 | step = d[0] 202 | d = sum(d) 203 | for j in count(i + d, d): 204 | q = self.board[j] 205 | # inside the board 206 | if q.isspace(): 207 | break 208 | # friend chess 209 | if q.isupper() and p != 'C': 210 | break 211 | if p == 'C': 212 | if cannon_flag: 213 | if q.islower(): 214 | pass 215 | elif q.isupper(): 216 | break 217 | else: 218 | continue 219 | # cannon need a carriage to attack opponent 220 | elif q.isalpha(): 221 | cannon_flag = True 222 | continue 223 | # horse and elephant leg should not be crappy 224 | if p in ('H', 'E') and self.board[i + step] != '.': 225 | break 226 | # king and advisor should stay in palace 227 | if p in ('A', 'K'): 228 | row, column = j // BOARD_COLUMN, j % BOARD_COLUMN 229 | if not (9 <= row <= BOARD_COLUMN and 4 <= column <= 6): 230 | break 231 | # elephant cannot go across river 232 | if p == 'E' and not 6 <= j // BOARD_COLUMN <= BOARD_COLUMN: 233 | break 234 | # pawn can move east or west only after crossing river 235 | if p == 'P' and j // BOARD_COLUMN > 6 and d in (E, W): 236 | break 237 | # two kings cannot see each other 238 | black_king = self.board.index('k') 239 | if p == 'K': 240 | red_king = j 241 | else: 242 | red_king = self.board.index('K') 243 | if black_king % BOARD_COLUMN == red_king % BOARD_COLUMN: 244 | if not any(piece != '.' for piece in self.board[black_king+BOARD_COLUMN:red_king:BOARD_COLUMN]): 245 | break 246 | 247 | # Move it 248 | yield i, j 249 | if p in 'HPEAK' or q.islower(): 250 | break 251 | 252 | def rotate(self): 253 | """ Rotates the board""" 254 | return Position(self.board[::-1].swapcase(), -self.score) 255 | 256 | def put(self, board, i, p): 257 | return board[:i] + p + board[i + 1:] 258 | 259 | def move(self, move): 260 | i, j = move 261 | # Copy variables and reset ep and kp 262 | board = self.board 263 | score = self.score + self.value(move) 264 | # Actual move 265 | board = self.put(board, j, board[i]) 266 | board = self.put(board, i, '.') 267 | return Position(board, score).rotate() 268 | 269 | def value(self, move): 270 | i, j = move 271 | p, q = self.board[i], self.board[j] 272 | MOVE_COST = 0 273 | # Actual move 274 | score = pst[p][j] - pst[p][i] - MOVE_COST 275 | # Capture 276 | if q.islower(): 277 | score += pst[q.upper()][BOARD_ROW * BOARD_COLUMN-1 - j] 278 | return score 279 | 280 | 281 | ############################################################################### 282 | # Search logic 283 | ############################################################################### 284 | 285 | # lower <= s(pos) <= upper 286 | Entry = namedtuple('Entry', 'lower upper') 287 | 288 | 289 | class Searcher: 290 | def __init__(self): 291 | self.tp_score = {} 292 | self.tp_move = {} 293 | self.history = set() 294 | 295 | def bound(self, pos, mid, depth, root=True): 296 | """ returns r where 297 | s(pos) <= r < mid if mid > s(pos) 298 | mid <= r <= s(pos) if mid <= s(pos)""" 299 | 300 | # Depth <= 0 is QSearch. Here any position is searched as deeply as is needed for 301 | # calmness, and from this point on there is no difference in behaviour depending on 302 | # depth, so so there is no reason to keep different depths in the transposition table. 303 | depth = max(depth, 0) 304 | 305 | # Sunfish is a king-capture engine, so we should always check if we 306 | # still have a king. Notice since this is the only termination check, 307 | # the remaining code has to be comfortable with being mated, stalemated 308 | # or able to capture the opponent king. 309 | if pos.score <= -MATE_LOWER: 310 | return -MATE_UPPER 311 | 312 | # We detect 3-fold captures by comparing against previously 313 | # _actually played_ positions. 314 | # Note that we need to do this before we look in the table, as the 315 | # position may have been previously reached with a different score. 316 | # This is what prevents a search instability. 317 | # FIXME: This is not true, since other positions will be affected by 318 | # the new values for all the drawn positions. 319 | if DRAW_TEST: 320 | if not root and pos in self.history: 321 | return 0 322 | 323 | # Look in the table if we have already searched this position before. 324 | # We also need to be sure, that the stored search was over the same 325 | # nodes as the current search. 326 | entry = self.tp_score.get( 327 | (pos, depth, root), Entry(-MATE_UPPER, MATE_UPPER)) 328 | if entry.lower >= mid and (not root or self.tp_move.get(pos) is not None): 329 | return entry.lower 330 | if entry.upper < mid: 331 | return entry.upper 332 | 333 | # Here extensions may be added 334 | # Such as 'if in_check: depth += 1' 335 | 336 | # Generator of moves to search in order. 337 | # This allows us to define the moves, but only calculate them if needed. 338 | def moves(): 339 | # First try not moving at all. We only do this if there is at least one major 340 | # piece left on the board, since otherwise zugzwangs are too dangerous. 341 | if depth > 0 and not root and any(c in pos.board for c in 'RHCP'): 342 | yield None, -self.bound(pos.rotate(), 1 - mid, depth - 3, root=False) 343 | # For QSearch we have a different kind of null-move, namely we can just stop 344 | # and not capture anything else. 345 | if depth == 0: 346 | yield None, pos.score 347 | # Then killer move. We search it twice, but the tp will fix things for us. 348 | # Note, we don't have to check for legality, since we've already done it 349 | # before. Also note that in QS the killer must be a capture, otherwise we 350 | # will be non deterministic. 351 | killer = self.tp_move.get(pos) 352 | if killer and (depth > 0 or pos.value(killer) >= QS_LIMIT): 353 | yield killer, -self.bound(pos.move(killer), 1 - mid, depth - 1, root=False) 354 | # Then all the other moves 355 | for move in sorted(pos.gen_moves(), key=pos.value, reverse=True): 356 | # for val, move in sorted(((pos.value(move), move) for move in pos.gen_moves()), reverse=True): 357 | # If depth == 0 we only try moves with high intrinsic score (captures and 358 | # promotions). Otherwise we do all moves. 359 | if depth > 0 or pos.value(move) >= QS_LIMIT: 360 | yield move, -self.bound(pos.move(move), 1 - mid, depth - 1, root=False) 361 | 362 | # Run through the moves, shortcutting when possible 363 | best = -MATE_UPPER 364 | for move, score in moves(): 365 | best = max(best, score) 366 | if best >= mid: 367 | # Clear before setting, so we always have a value 368 | if len(self.tp_move) > TABLE_SIZE: 369 | self.tp_move.clear() 370 | # Save the move for pv construction and killer heuristic 371 | self.tp_move[pos] = move 372 | break 373 | 374 | # Stalemate checking is a bit tricky: Say we failed low, because 375 | # we can't (legally) move and so the (real) score is -infinity. 376 | # At the next depth we are allowed to just return r, -infinity <= r < gamma, 377 | # which is normally fine. 378 | # However, what if gamma = -10 and we don't have any legal moves? 379 | # Then the score is actually a draw and we should fail high! 380 | # Thus, if best < gamma and best < 0 we need to double check what we are doing. 381 | # This doesn't prevent sunfish from making a move that results in stalemate, 382 | # but only if depth == 1, so that's probably fair enough. 383 | # (Btw, at depth 1 we can also mate without realizing.) 384 | if best < mid and best < 0 and depth > 0: 385 | def is_dead(pos): return any(pos.value(m) >= 386 | MATE_LOWER for m in pos.gen_moves()) 387 | if all(is_dead(pos.move(m)) for m in pos.gen_moves()): 388 | in_check = is_dead(pos.rotate()) 389 | best = -MATE_UPPER if in_check else 0 390 | 391 | # Clear before setting, so we always have a value 392 | if len(self.tp_score) > TABLE_SIZE: 393 | self.tp_score.clear() 394 | # Table part 2 395 | if best >= mid: 396 | self.tp_score[pos, depth, root] = Entry(best, entry.upper) 397 | if best < mid: 398 | self.tp_score[pos, depth, root] = Entry(entry.lower, best) 399 | 400 | return best 401 | 402 | def search(self, pos, history=()): 403 | """ Iterative deepening MTD-bi search """ 404 | if DRAW_TEST: 405 | self.history = set(history) 406 | # print('# Clearing table due to new history') 407 | self.tp_score.clear() 408 | 409 | # In finished games, we could potentially go far enough to cause a recursion 410 | # limit exception. Hence we bound the ply. 411 | for depth in range(1, 1000): 412 | # The inner loop is a binary search on the score of the position. 413 | # Inv: lower <= score <= upper 414 | # 'while lower != upper' would work, but play tests show a margin of 20 plays 415 | # better. 416 | lower, upper = -MATE_UPPER, MATE_UPPER 417 | while lower < upper - EVAL_ROUGHNESS: 418 | mid = (lower + upper + 1) // 2 419 | score = self.bound(pos, mid, depth) 420 | if score >= mid: 421 | lower = score 422 | if score < mid: 423 | upper = score 424 | # We want to make sure the move to play hasn't been kicked out of the table, 425 | # So we make another call that must always fail high and thus produce a move. 426 | self.bound(pos, lower, depth) 427 | # If the game hasn't finished we can retrieve our move from the 428 | # transposition table. 429 | yield depth, self.tp_move.get(pos), self.tp_score.get((pos, depth, True)).lower 430 | 431 | 432 | ############################################################################### 433 | # User interface 434 | ############################################################################### 435 | 436 | A1 = CHESS_ROW*BOARD_COLUMN+1 437 | 438 | 439 | def parse(c): 440 | fil, rank = ord(c[0]) - ord('a'), int(c[1]) - 1 441 | return A1 + fil - BOARD_COLUMN * rank 442 | 443 | 444 | def render(i): 445 | rank, fil = divmod(i - A1, BOARD_COLUMN) 446 | return chr(fil + ord('a')) + str(-rank + 1) 447 | 448 | 449 | def print_pos(pos, width=2, piece_type='unicode'): 450 | print() 451 | if piece_type == 'unicode': 452 | pieces = uni_pieces 453 | else: 454 | pieces = chinese_pieces 455 | space = ' '*width 456 | for i, row in enumerate(pos.board.split()): 457 | print(' ', CHESS_ROW - 1 - i, ' '.join(pieces.get(p, p) for p in row)) 458 | print(' '+space.join('abcdefghi\n')) 459 | 460 | 461 | def parse_move(move, board, is_red): 462 | # import ipdb 463 | # ipdb.set_trace() 464 | piece = board[move[0]] 465 | number_chinese = dict(zip(range(1, 10), '一二三四五六七八九')) 466 | name = chinese_pieces[piece if is_red else piece.lower()] 467 | row = CHESS_COLUMN + 1 - move[0] % BOARD_COLUMN 468 | direction = move[0]//BOARD_COLUMN-move[1]//BOARD_COLUMN 469 | index = int(direction/abs(direction)) if direction != 0 else 0 470 | action = ['平', '进', '退'][index] 471 | if index == 0 or piece in 'AEH': 472 | destionation = CHESS_COLUMN + 1 - move[1] % BOARD_COLUMN 473 | else: 474 | destionation = abs(direction) 475 | if is_red: 476 | row = number_chinese[row] 477 | destionation = number_chinese[destionation] 478 | else: 479 | row, destionation = str(row), str(destionation) 480 | if piece in 'CHPR': 481 | all_row = [m.start() for m in re.finditer(piece, board) 482 | if m.start() % BOARD_COLUMN == move[0] % BOARD_COLUMN] 483 | if len(all_row) >= 2: 484 | all_row.remove(move[0]) 485 | row = '前' if all_row[0] > move[0] else '后' 486 | print(row+name+action+destionation) 487 | return 488 | print(name+row+action+destionation) 489 | 490 | 491 | def main(arg): 492 | hist = [Position(initial, 0)] 493 | searcher = Searcher() 494 | while True: 495 | print_pos(hist[-1], arg.width, arg.piece) 496 | 497 | if hist[-1].score <= -MATE_LOWER: 498 | print("You lost") 499 | break 500 | 501 | # We query the user until she enters a (pseudo) legal move. 502 | move = None 503 | 504 | while True: 505 | match = re.match('([a-i][0-9])' * 2, input('Your move: ')) 506 | # match = re.match('([a-i][0-9])' * 2, 'e0d0') 507 | if match: 508 | move = parse(match.group(1)), parse(match.group(2)) 509 | if move not in hist[-1].gen_moves(): 510 | print('Invalid move') 511 | else: 512 | break 513 | else: 514 | # Inform the user when invalid input (e.g. "help") is entered 515 | print("Please enter a move like h2e2") 516 | parse_move(move, hist[-1].board, True) 517 | hist.append(hist[-1].move(move)) 518 | 519 | # After our move we rotate the board and print it again. 520 | # This allows us to see the effect of our move. 521 | print_pos(hist[-1].rotate(), arg.width, arg.piece) 522 | 523 | if hist[-1].score <= -MATE_LOWER: 524 | print("You won") 525 | break 526 | 527 | # Fire up the engine to look for a move. 528 | start = time.perf_counter() 529 | for _, move, score in searcher.search(hist[-1], hist): 530 | if time.perf_counter() - start > 1: 531 | break 532 | 533 | if score == MATE_UPPER: 534 | print("Checkmate!") 535 | 536 | # The black player moves from a rotated position, so we have to 537 | # 'back rotate' the move before printing it. 538 | print("My move: ", end='') 539 | parse_move(move, hist[-1].board, False) 540 | hist.append(hist[-1].move(move)) 541 | 542 | 543 | if __name__ == '__main__': 544 | parser = argparse.ArgumentParser(description="xiangqi(Chinese Chess)") 545 | parser.add_argument('-p', '--piece', default='unicode', type=str, choices=['unicode', 'chinese'], 546 | help="Choose unicode if you can distringuish these two character:🩤, 🩣. Otherwise choose chinese.") 547 | parser.add_argument('-w', '--width', type=int, default=1, 548 | help='num of space between two pieces.') 549 | main(parser.parse_args()) 550 | --------------------------------------------------------------------------------