Upload 19 files

backgammon-1.0.0/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

backgammon-1.0.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: backgammon
+Version: 1.0.0
+Summary: Backgammon engine for the Backgammon Network.
+Home-page: https://github.com/softwerks/backgammon
+Author: Softwerks
+Author-email: info@softwerks.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+backgammon
+==========
+
+Backgammon engine for the `Backgammon Network <https://www.bkgmn.net>`_.
+
+Installation
+------------
+
+.. code-block:: bash
+
+    $ pip install backgammon
+
+Getting Started
+---------------
+
+.. code-block:: pycon
+
+    >>> import backgammon
+    >>> b = backgammon.Backgammon("4OvgATDgc+QBUA", "cInpAAAAAAAA")
+    >>> print(b)
+                     Position ID: 4OvgATDgc+QBUA
+                     Match ID   : cInpAAAAAAAA
+     +13-14-15-16-17-18------19-20-21-22-23-24-+
+     | X           O  O |   | O              X |
+     | X           O    |   | O                |
+     | X           O    |   | O                |
+     | X                |   | O                |
+     |                  |   | O                |
+    v|                  |BAR|                  |
+     |                  |   | X                |
+     | O                |   | X                |
+     | O           X    |   | X                |
+     | O           X    |   | X              O |
+     | O  X        X    | X | X              O |
+     +12-11-10--9--8--7-------6--5--4--3--2--1-+
+    >>> for play in b.generate_plays():
+    ...     print(play.moves)
+    ...     print(play.position)
+    ...
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=13, destination=11))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 2, -4, 3, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=24, destination=21))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 1, 0, 1, 0), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=11, destination=9))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 1, 0, 0, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=22, destination=20))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 1, 0, 0, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=13, destination=10))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 1, 1, -4, 3, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=8, destination=5))
+    Position(board_points=(-2, 0, 0, 0, 1, 5, 0, 2, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=24, destination=22))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 2, 0, 0), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=6, destination=4))
+    Position(board_points=(-2, 0, 0, 1, 0, 4, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=6, destination=3))
+    Position(board_points=(-2, 0, 1, 0, 0, 4, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=11, destination=8))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 4, 0, 0, 0, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=8, destination=6))
+    Position(board_points=(-2, 0, 0, 0, 0, 6, 0, 2, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+
+

backgammon-1.0.0/README.rst

@@ -0,0 +1,61 @@
+backgammon
+==========
+
+Backgammon engine for the `Backgammon Network <https://www.bkgmn.net>`_.
+
+Installation
+------------
+
+.. code-block:: bash
+
+    $ pip install backgammon
+
+Getting Started
+---------------
+
+.. code-block:: pycon
+
+    >>> import backgammon
+    >>> b = backgammon.Backgammon("4OvgATDgc+QBUA", "cInpAAAAAAAA")
+    >>> print(b)
+                     Position ID: 4OvgATDgc+QBUA
+                     Match ID   : cInpAAAAAAAA
+     +13-14-15-16-17-18------19-20-21-22-23-24-+
+     | X           O  O |   | O              X |
+     | X           O    |   | O                |
+     | X           O    |   | O                |
+     | X                |   | O                |
+     |                  |   | O                |
+    v|                  |BAR|                  |
+     |                  |   | X                |
+     | O                |   | X                |
+     | O           X    |   | X                |
+     | O           X    |   | X              O |
+     | O  X        X    | X | X              O |
+     +12-11-10--9--8--7-------6--5--4--3--2--1-+
+    >>> for play in b.generate_plays():
+    ...     print(play.moves)
+    ...     print(play.position)
+    ...
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=13, destination=11))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 2, -4, 3, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=24, destination=21))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 1, 0, 1, 0), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=11, destination=9))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 1, 0, 0, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=22, destination=20))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 1, 0, 0, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=13, destination=10))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 1, 1, -4, 3, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=8, destination=5))
+    Position(board_points=(-2, 0, 0, 0, 1, 5, 0, 2, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=24, destination=22))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 2, 0, 0), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=6, destination=4))
+    Position(board_points=(-2, 0, 0, 1, 0, 4, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=6, destination=3))
+    Position(board_points=(-2, 0, 1, 0, 0, 4, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=11, destination=8))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 4, 0, 0, 0, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=8, destination=6))
+    Position(board_points=(-2, 0, 0, 0, 0, 6, 0, 2, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)

backgammon-1.0.0/backgammon.egg-info/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.1
+Name: backgammon
+Version: 1.0.0
+Summary: Backgammon engine for the Backgammon Network.
+Home-page: https://github.com/softwerks/backgammon
+Author: Softwerks
+Author-email: info@softwerks.com
+License: UNKNOWN
+Platform: UNKNOWN
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+
+backgammon
+==========
+
+Backgammon engine for the `Backgammon Network <https://www.bkgmn.net>`_.
+
+Installation
+------------
+
+.. code-block:: bash
+
+    $ pip install backgammon
+
+Getting Started
+---------------
+
+.. code-block:: pycon
+
+    >>> import backgammon
+    >>> b = backgammon.Backgammon("4OvgATDgc+QBUA", "cInpAAAAAAAA")
+    >>> print(b)
+                     Position ID: 4OvgATDgc+QBUA
+                     Match ID   : cInpAAAAAAAA
+     +13-14-15-16-17-18------19-20-21-22-23-24-+
+     | X           O  O |   | O              X |
+     | X           O    |   | O                |
+     | X           O    |   | O                |
+     | X                |   | O                |
+     |                  |   | O                |
+    v|                  |BAR|                  |
+     |                  |   | X                |
+     | O                |   | X                |
+     | O           X    |   | X                |
+     | O           X    |   | X              O |
+     | O  X        X    | X | X              O |
+     +12-11-10--9--8--7-------6--5--4--3--2--1-+
+    >>> for play in b.generate_plays():
+    ...     print(play.moves)
+    ...     print(play.position)
+    ...
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=13, destination=11))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 2, -4, 3, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=24, destination=21))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 1, 0, 1, 0), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=11, destination=9))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 1, 0, 0, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=22, destination=20))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 1, 0, 0, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=13, destination=10))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 1, 1, -4, 3, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=8, destination=5))
+    Position(board_points=(-2, 0, 0, 0, 1, 5, 0, 2, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=24, destination=22))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 2, 0, 0), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=6, destination=4))
+    Position(board_points=(-2, 0, 0, 1, 0, 4, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=6, destination=3))
+    Position(board_points=(-2, 0, 1, 0, 0, 4, 0, 3, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=2, source=None, destination=23), Move(pips=3, source=11, destination=8))
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 4, 0, 0, 0, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 0, 1, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+    (Move(pips=3, source=None, destination=22), Move(pips=2, source=8, destination=6))
+    Position(board_points=(-2, 0, 0, 0, 0, 6, 0, 2, 0, 0, 1, -4, 4, 0, 0, 0, -3, -1, -5, 0, 0, 1, 0, 1), player_bar=0, player_off=1, opponent_bar=0, opponent_off=0)
+
+

backgammon-1.0.0/backgammon.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.rst
+setup.py
+backgammon/__init__.py
+backgammon/__main__.py
+backgammon/backgammon.py
+backgammon/match.py
+backgammon/position.py
+backgammon.egg-info/PKG-INFO
+backgammon.egg-info/SOURCES.txt
+backgammon.egg-info/dependency_links.txt
+backgammon.egg-info/top_level.txt
+tests/__init__.py
+tests/test_backgammon.py
+tests/test_match.py
+tests/test_position.py

backgammon-1.0.0/backgammon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

backgammon-1.0.0/backgammon.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+backgammon
+tests

backgammon-1.0.0/backgammon/__init__.py

@@ -0,0 +1,15 @@
+# Copyright 2020 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from backgammon.backgammon import Backgammon

backgammon-1.0.0/backgammon/__main__.py

@@ -0,0 +1,109 @@
+# Copyright 2020 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import cmd
+from typing import cast, List, Optional, Tuple
+
+try:
+    import readline
+except ImportError:
+    pass
+
+from backgammon.backgammon import Backgammon, BackgammonError
+from backgammon.match import GameState, Player
+
+
+class BackgammonShell(cmd.Cmd):
+    intro: str = "Type 'help' or '?' to list commands."
+    prompt: str = "backgammon> "
+    game: Backgammon
+
+    def do_new(self, arg: str) -> None:
+        """Start a new game."""
+        die_1: int
+        die_2: int
+
+        if (
+            hasattr(self, "game")
+            and self.game.match.game_state is not GameState.NOT_STARTED
+        ):
+            print("Game already started.")
+            return
+
+        self.game = Backgammon()
+        die_1, die_2 = self.game.first_roll()
+        self.game.match.game_state = GameState.PLAYING
+
+        print(f"Rolled {die_1} {die_2}")
+        print(self.game)
+
+    def do_move(self, arg: str) -> None:
+        """Make a backgammon move: move <from> <to> ..."""
+        Moves = Tuple[Tuple[Optional[int], Optional[int]], ...]
+
+        def parse_arg(arg: str) -> Moves:
+            arg_ints: List[Optional[int]] = list(
+                map(lambda n: int(n) if n.isdigit() else None, arg.split())
+            )
+
+            if len(arg_ints) % 2 == 1:
+                raise ValueError("Incomplete move.")
+            if len(arg_ints) > 8:
+                raise ValueError("Too many moves.")
+
+            return cast(
+                Moves,
+                tuple(tuple(arg_ints[i : i + 2]) for i in range(0, len(arg_ints), 2)),
+            )
+
+        if (
+            not hasattr(self, "game")
+            or self.game.match.game_state is not GameState.PLAYING
+        ):
+            print("Game not in progress.")
+            return
+
+        try:
+            moves: Moves = parse_arg(arg)
+        except ValueError as e:
+            print(e)
+            return
+
+        try:
+            self.game.play(moves)
+        except BackgammonError:
+            print("Illegal move.")
+            return
+
+        if self.game.match.game_state is GameState.GAME_OVER:
+            print(f"P{1 if self.game.match.player is Player.ZERO else 2} wins")
+            print(self.game)
+            del self.game
+        else:
+            self.game.end_turn()
+
+            die_1, die_2 = self.game.roll()
+            print(f"Rolled {die_1} {die_2}")
+            print(self.game)
+
+    def do_quit(self, arg: str) -> bool:
+        """Exit the program."""
+        return True
+
+
+if __name__ == "__main__":
+    try:
+        BackgammonShell().cmdloop()
+    except KeyboardInterrupt:
+        print("^C")

backgammon-1.0.0/backgammon/backgammon.py

@@ -0,0 +1,383 @@
+# Copyright 2020 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import enum
+import itertools
+import json
+import operator
+import random
+from typing import Callable, List, NamedTuple, Optional, Tuple, Set
+
+import backgammon.match
+from backgammon.match import Player, GameState, Resign
+import backgammon.position
+
+MatchType = backgammon.match.Match
+PositionType = backgammon.position.Position
+
+STARTING_POSITION_ID = "4HPwATDgc/ABMA"
+STARTING_MATCH_ID = "cAgAAAAAAAAA"
+
+CHECKERS = 15
+POINTS = 24
+POINTS_PER_QUADRANT = int(POINTS / 4)
+
+ASCII_BOARD_HEIGHT = 11
+ASCII_MAX_CHECKERS = 5
+ASCII_13_24 = "+13-14-15-16-17-18------19-20-21-22-23-24-+"
+ASCII_12_01 = "+12-11-10--9--8--7-------6--5--4--3--2--1-+"
+
+
+class BackgammonError(Exception):
+    pass
+
+
+class MoveState(enum.Enum):
+    BEAR_OFF = enum.auto()
+    ENTER_FROM_BAR = enum.auto()
+    DEFAULT = enum.auto()
+
+
+class Move(NamedTuple):
+    pips: int
+    source: Optional[int]
+    destination: Optional[int]
+
+
+class Play(NamedTuple):
+    moves: Tuple[Move, ...]
+    position: PositionType
+
+
+class Backgammon:
+    def __init__(
+        self, position_id: str = STARTING_POSITION_ID, match_id: str = STARTING_MATCH_ID
+    ):
+        self.position: PositionType = backgammon.position.decode(position_id)
+        self.match: MatchType = backgammon.match.decode(match_id)
+
+    def generate_plays(self) -> List[Play]:
+        """Generate and return legal plays."""
+
+        def generate(
+            position: PositionType,
+            dice: Tuple[int, ...],
+            die: int = 0,
+            moves: Tuple[Move, ...] = (),
+            plays: List[Play] = [],
+        ) -> List[Play]:
+            """Generate and return all plays."""
+            new_position: Optional[PositionType]
+            destination: Optional[int]
+            point: int
+            num_checkers: int
+            pips: int
+
+            if die < len(dice):
+                pips = dice[die]
+
+                if position.player_bar > 0:
+                    new_position, destination = position.enter(pips)
+                    if new_position:
+                        generate(
+                            new_position,
+                            dice,
+                            die + 1,
+                            moves + (Move(pips, None, destination),),
+                            plays,
+                        )
+                elif sum(position.player_home()) + position.player_off == CHECKERS:
+                    for point, num_checkers in enumerate(
+                        position.board_points[:POINTS_PER_QUADRANT]
+                    ):
+                        new_position, destination = position.off(point, pips)
+                        if new_position:
+                            generate(
+                                new_position,
+                                dice,
+                                die + 1,
+                                moves + (Move(pips, point, destination),),
+                                plays,
+                            )
+                else:
+                    for point, num_checkers in enumerate(position.board_points):
+                        new_position, destination = position.move(point, pips)
+                        if new_position:
+                            generate(
+                                new_position,
+                                dice,
+                                die + 1,
+                                moves + (Move(pips, point, destination),),
+                                plays,
+                            )
+
+            if len(moves) > 0:
+                plays.append(Play(moves, position))
+
+            return plays
+
+        doubles: bool = self.match.dice[0] == self.match.dice[1]
+        dice: Tuple[int, ...] = self.match.dice * 2 if doubles else self.match.dice
+
+        plays: List[Play] = generate(self.position, dice)
+        if not doubles:
+            plays += generate(self.position, dice[::-1])
+
+        if plays:
+            max_moves: int = max(len(p.moves) for p in plays)
+            if max_moves == 1:
+                max_pips: int = max(dice)
+                higher_plays: List[Play] = list(
+                    filter(lambda p: p.moves[0].pips == max_pips, plays)
+                )
+                if higher_plays:
+                    plays = higher_plays
+            else:
+                plays = list(filter(lambda p: len(p.moves) == max_moves, plays))
+
+            key_func: Callable = lambda p: hash(p.position)
+            plays = sorted(plays, key=key_func)
+            plays = list(
+                map(
+                    next,
+                    map(operator.itemgetter(1), itertools.groupby(plays, key_func)),
+                )
+            )
+
+        return plays
+
+    def start(self, length: int = 3) -> "Backgammon":
+        self.match.game_state = GameState.PLAYING
+        self.match.length = length
+        self.first_roll()
+
+        return self
+
+    def roll(self) -> Tuple[int, int]:
+        if self.match.dice != (0, 0):
+            raise BackgammonError(f"Dice have already been rolled: {self.match.dice}")
+
+        self.match.dice = (
+            random.SystemRandom().randrange(1, 6),
+            random.SystemRandom().randrange(1, 6),
+        )
+        return self.match.dice
+
+    def first_roll(self) -> Tuple[int, int]:
+        while True:
+            self.match.dice = (
+                random.SystemRandom().randrange(1, 6),
+                random.SystemRandom().randrange(1, 6),
+            )
+            if self.match.dice[0] != self.match.dice[1]:
+                break
+        if self.match.dice[0] > self.match.dice[1]:
+            self.match.player = Player.ZERO
+            self.match.turn = Player.ZERO
+        else:
+            self.match.player = Player.ONE
+            self.match.turn = Player.ONE
+        return self.match.dice
+
+    def play(
+        self, moves: Tuple[Tuple[Optional[int], Optional[int]], ...]
+    ) -> "Backgammon":
+        """Excecute a play, a sequence of moves."""
+        new_position: PositionType = self.position
+        for source, destination in moves:
+            new_position = new_position.apply_move(source, destination)
+
+        legal_plays: List[Play] = self.generate_plays()
+
+        if new_position in [play.position for play in legal_plays]:
+            self.position = new_position
+
+            if self.position.player_off == CHECKERS:
+                multiplier: int = 1
+                if self.position.opponent_off == 0:
+                    if (
+                        self.position.opponent_bar > 0
+                        or sum(self.position.board_points[:POINTS_PER_QUADRANT]) != 0
+                    ):
+                        multiplier = 3
+                    else:
+                        multiplier = 2
+                self.match.update_score(multiplier)
+                if self.match.game_state is GameState.PLAYING:
+                    self.match.reset_cube()
+                    self.position = backgammon.position.decode(STARTING_POSITION_ID)
+                    self.first_roll()
+            else:
+                self.end_turn()
+
+        else:
+            position_id: str = self.position.encode()
+            match_id: str = self.match.encode()
+            raise BackgammonError(f"Invalid move: {position_id}:{match_id} {moves}")
+
+        return self
+
+    def double(self) -> "Backgammon":
+        if self.match.dice != (0, 0):
+            raise BackgammonError("Cannot double: dice have been rolled")
+        elif (
+            self.match.cube_holder is not Player.CENTERED
+            and self.match.cube_holder is not self.match.player
+        ):
+            raise BackgammonError("Cannot double: not cube holder")
+        elif self.match.double:
+            raise BackgammonError("Cannot double: already doubled")
+        elif (
+            self.match.player_0_score
+            if self.match.player is Player.ZERO
+            else self.match.player_1_score + self.match.cube_value >= self.match.length
+        ):
+            raise BackgammonError("Cannot double: dead cube")
+        elif self.match.crawford:
+            raise BackgammonError("Cannot double: crawford game")
+
+        self.match.double = True
+        self.match.swap_turn()
+
+        return self
+
+    def accept_double(self) -> "Backgammon":
+        if self.match.double:
+            self.match.double = False
+            self.match.cube_value *= 2
+            self.match.cube_holder = (
+                Player.ZERO if self.match.turn is Player.ZERO else Player.ONE
+            )
+            self.match.swap_turn()
+        else:
+            raise BackgammonError("Cannot accept double: double not offered")
+
+        return self
+
+    def reject_double(self) -> "Backgammon":
+        if self.match.double:
+            self.match.drop_cube()
+            if self.match.game_state is GameState.PLAYING:
+                self.match.reset_cube()
+                self.position = backgammon.position.decode(STARTING_POSITION_ID)
+                self.first_roll()
+        else:
+            raise BackgammonError("Cannot reject double: double not offered")
+
+        return self
+
+    def skip(self) -> "Backgammon":
+        num_plays: int = len(self.generate_plays())
+        if num_plays == 0:
+            self.end_turn()
+        else:
+            raise BackgammonError(f"Cannot skip turn: {num_plays} possible plays")
+
+        return self
+
+    def end_turn(self) -> "Backgammon":
+        self.position = self.position.swap_players()
+        self.match.swap_players()
+        self.match.reset_dice()
+
+        return self
+
+    def encode(self) -> str:
+        return f"{self.position.encode()}:{self.match.encode()}"
+
+    def __repr__(self):
+        position_id: str = self.position.encode()
+        match_id: str = self.match.encode()
+        return f"{__name__}.{self.__class__.__name__}('{position_id}', '{match_id}')"
+
+    def __str__(self):
+        def checkers(top: List[int], bottom: List[int]) -> List[List[str]]:
+            """Return an ASCII checker matrix."""
+            ascii_checkers: List[List[str]] = [
+                ["   " for j in range(len(top))] for i in range(ASCII_BOARD_HEIGHT)
+            ]
+
+            for half in (top, bottom):
+                for col, num_checkers in enumerate(half):
+                    row: int = 0 if half is top else len(ascii_checkers) - 1
+                    for i in range(abs(num_checkers)):
+                        if (
+                            abs(num_checkers) > ASCII_MAX_CHECKERS
+                            and i == ASCII_MAX_CHECKERS - 1
+                        ):
+                            ascii_checkers[row][col] = f" {abs(num_checkers)} "
+                            break
+                        ascii_checkers[row][col] = " O " if num_checkers > 0 else " X "
+                        row += 1 if half is top else -1
+
+            return ascii_checkers
+
+        def split(position: List[int]) -> Tuple[List[int], List[int]]:
+            """Return a position split into top (Player.ZERO 12-1) and bottom (Player.ZERO 13-24) halves."""
+
+            def normalize(position: List[int]) -> List[int]:
+                """Return position for Player.ZERO"""
+                if self.match.player is Player.ONE:
+                    position = list(map(lambda n: -n, position[::-1]))
+                return position
+
+            position = normalize(position)
+
+            half_len: int = int(len(position) / 2)
+            top: List[int] = position[:half_len][::-1]
+            bottom: List[int] = position[half_len:]
+
+            return top, bottom
+
+        points: List[List[str]] = checkers(*split(self.position.board_points))
+
+        bar: List[List[str]] = checkers(
+            *split(
+                [
+                    self.position.player_bar,
+                    -self.position.opponent_bar,
+                ]
+            )
+        )
+
+        ascii_board: str = ""
+        position_id: str = self.position.encode()
+        ascii_board += f"                 Position ID: {position_id}\n"
+        match_id: str = self.match.encode()
+        ascii_board += f"                 Match ID   : {match_id}\n"
+        ascii_board += (
+            " "
+            + (ASCII_12_01 if self.match.player is Player.ZERO else ASCII_13_24)
+            + "\n"
+        )
+        for i in range(len(points)):
+            ascii_board += (
+                ("^|" if self.match.player is Player.ZERO else "v|")
+                if i == int(ASCII_BOARD_HEIGHT / 2)
+                else " |"
+            )
+            ascii_board += "".join(points[i][:POINTS_PER_QUADRANT])
+            ascii_board += "|"
+            ascii_board += "BAR" if i == int(ASCII_BOARD_HEIGHT / 2) else bar[i][0]
+            ascii_board += "|"
+            ascii_board += "".join(points[i][POINTS_PER_QUADRANT:])
+            ascii_board += "|"
+            ascii_board += "\n"
+        ascii_board += (
+            " "
+            + (ASCII_13_24 if self.match.player is Player.ZERO else ASCII_12_01)
+            + "\n"
+        )
+
+        return ascii_board

backgammon-1.0.0/backgammon/match.py

@@ -0,0 +1,177 @@
+# Copyright 2020 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import base64
+import dataclasses
+import enum
+import math
+import struct
+from typing import Tuple
+
+
+@enum.unique
+class Player(enum.IntEnum):
+    ZERO = 0b00
+    ONE = 0b01
+    CENTERED = 0b11
+
+
+@enum.unique
+class GameState(enum.IntEnum):
+    NOT_STARTED = 0b000
+    PLAYING = 0b001
+    GAME_OVER = 0b010
+    RESIGNED = 0b011
+    DROPPED_CUBE = 0b100
+
+
+@enum.unique
+class Resign(enum.IntEnum):
+    NONE = 0b00
+    SINGLE_GAME = 0b01
+    GAMMON = 0b10
+    BACKGAMMON = 0b11
+
+
+@dataclasses.dataclass
+class Match:
+    cube_value: int
+    cube_holder: Player
+    player: Player
+    crawford: bool
+    game_state: GameState
+    turn: Player
+    double: bool
+    resign: Resign
+    dice: Tuple[int, int]
+    length: int
+    player_0_score: int
+    player_1_score: int
+
+    def swap_players(self) -> "Match":
+        self.player = self.turn = (
+            Player.ZERO if self.player is Player.ONE else Player.ONE
+        )
+
+        return self
+
+    def swap_turn(self) -> "Match":
+        self.turn = Player.ZERO if self.turn is Player.ONE else Player.ONE
+
+        return self
+
+    def reset_dice(self) -> "Match":
+        self.dice = (0, 0)
+
+        return self
+
+    def reset_cube(self) -> "Match":
+        self.cube_holder = Player.CENTERED
+        self.cube_value = 1
+
+        return self
+
+    def drop_cube(self) -> "Match":
+        if self.player is Player.ZERO:
+            self.player_0_score += self.cube_value
+        else:
+            self.player_1_score += self.cube_value
+
+        self.double = False
+
+        if self.player_0_score >= self.length or self.player_1_score >= self.length:
+            self.game_state = GameState.DROPPED_CUBE
+
+        return self
+
+    def update_score(self, multiplier: int) -> "Match":
+        points: int = self.cube_value * multiplier
+
+        self.crawford = False
+
+        if self.player is Player.ZERO:
+            self.player_0_score += points
+            if (
+                self.length - self.player_0_score == 1
+                and self.length - self.player_1_score > 1
+            ):
+                self.crawford = True
+        else:
+            self.player_1_score += points
+            if (
+                self.length - self.player_1_score == 1
+                and self.length - self.player_0_score > 1
+            ):
+                self.crawford = True
+
+        self.double = False
+
+        if self.player_0_score >= self.length or self.player_1_score >= self.length:
+            self.game_state = GameState.GAME_OVER
+
+        return self
+
+    def encode(self) -> str:
+        """Encode the match and return a match ID.
+
+        >>> match = Match(cube_value=2, cube_holder=Player.ZERO, player=Player.ONE, crawford=False, game_state=GameState.PLAYING, turn=Player.ONE, double=False, resign=Resign.NONE, dice=(5, 2), length=9, player_0_score=2, player_1_score=4)
+        >>> match.encode()
+        'QYkqASAAIAAA'
+        """
+        match_key: str = "".join(
+            (
+                f"{int(math.log(self.cube_value, 2)):04b}"[::-1],
+                f"{self.cube_holder.value:02b}"[::-1],
+                f"{self.player.value:b}",
+                f"{self.crawford:b}",
+                f"{self.game_state.value:03b}"[::-1],
+                f"{self.turn:b}",
+                f"{self.double:b}",
+                f"{self.resign.value:02b}"[::-1],
+                f"{self.dice[0]:03b}"[::-1],
+                f"{self.dice[1]:03b}"[::-1],
+                f"{self.length:015b}"[::-1],
+                f"{self.player_0_score:015b}"[::-1],
+                f"{self.player_1_score:015b}"[::-1],
+            )
+        )
+        byte_strings: Tuple[str, ...] = tuple(
+            match_key[i : i + 8][::-1] for i in range(0, len(match_key), 8)
+        )
+        match_bytes: bytes = struct.pack("9B", *(int(b, 2) for b in byte_strings))
+        return base64.b64encode(bytes(match_bytes)).decode()
+
+
+def decode(match_id: str) -> Match:
+    """Decode a match ID and return a Match.
+
+    >>> decode("QYkqASAAIAAA")
+    Match(cube_value=2, cube_holder=<Player.ZERO: 0>, player=<Player.ONE: 1>, crawford=False, game_state=<GameState.PLAYING: 1>, turn=<Player.ONE: 1>, double=False, resign=<Resign.NONE: 0>, dice=(5, 2), length=9, player_0_score=2, player_1_score=4)
+    """
+    match_bytes: bytes = base64.b64decode(match_id)
+    match_key: str = "".join([format(b, "08b")[::-1] for b in match_bytes])
+    return Match(
+        cube_value=2 ** int(match_key[0:4][::-1], 2),
+        cube_holder=Player(int(match_key[4:6][::-1], 2)),
+        player=Player(int(match_key[6])),
+        crawford=bool(int(match_key[7])),
+        game_state=GameState(int(match_key[8:11][::-1], 2)),
+        turn=Player(int(match_key[11])),
+        double=bool(int(match_key[12])),
+        resign=Resign(int(match_key[13:15][::-1], 2)),
+        dice=(int(match_key[15:18][::-1], 2), int(match_key[18:21][::-1], 2)),
+        length=int(match_key[21:36][::-1], 2),
+        player_0_score=int(match_key[36:51][::-1], 2),
+        player_1_score=int(match_key[51:66][::-1], 2),
+    )

backgammon-1.0.0/backgammon/position.py

@@ -0,0 +1,214 @@
+# Copyright 2020 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Position ID
+# https://www.gnu.org/software/gnubg/manual/html_node/A-technical-description-of-the-Position-ID.html
+# Official documentation is inaccurate. Position key (binary string) starts from the opponent's ace point. See:
+# https://lists.gnu.org/archive/html/bug-gnubg/2005-01/msg00081.html
+# https://lists.gnu.org/archive/html/bug-gnubg/2013-01/msg00010.html
+
+import base64
+import dataclasses
+import struct
+from typing import List, Optional, Tuple
+
+POINTS = 24
+POINTS_PER_QUADRANT = int(POINTS / 4)
+
+
+@dataclasses.dataclass(frozen=True)
+class Position:
+    board_points: Tuple[int, ...]
+    player_bar: int
+    player_off: int
+    opponent_bar: int
+    opponent_off: int
+
+    def enter(self, pips: int) -> Tuple[Optional["Position"], Optional[int]]:
+        """Try to enter from the bar and return the new position and destination."""
+        destination: int = POINTS - pips
+
+        if self.board_points[destination] >= -1:
+            return self.apply_move(None, destination), destination
+
+        return None, None
+
+    def player_home(self) -> Tuple[int, ...]:
+        """Return checkers in the player's home board."""
+        home_board: Tuple[int, ...] = self.board_points[:POINTS_PER_QUADRANT]
+
+        return tuple(point if point > 0 else 0 for point in home_board)
+
+    def off(self, point: int, pips: int) -> Tuple[Optional["Position"], Optional[int]]:
+        """Try to move a checker in the player's home board and return the new position and destination."""
+        if self.board_points[point] > 0:
+            destination: int = point - pips
+            if destination < 0:
+                checkers_on_higher_points: int = sum(
+                    self.player_home()[point + 1 : POINTS_PER_QUADRANT]
+                )
+                if destination == -1 or checkers_on_higher_points == 0:
+                    return self.apply_move(point, None), None
+            elif self.board_points[destination] >= -1:
+                return self.apply_move(point, destination), destination
+
+        return None, None
+
+    def move(self, point: int, pips: int) -> Tuple[Optional["Position"], Optional[int]]:
+        """Try to move a checker and return the new position and destination."""
+        if self.board_points[point] > 0:
+            destination: int = point - pips
+            if destination >= 0 and self.board_points[destination] >= -1:
+                return self.apply_move(point, destination), destination
+
+        return None, None
+
+    def apply_move(
+        self, source: Optional[int], destination: Optional[int]
+    ) -> "Position":
+        """Apply a move and return a new position."""
+        board_points: List[int] = list(self.board_points)
+        player_bar: int = self.player_bar
+        player_off: int = self.player_off
+        opponent_bar: int = self.opponent_bar
+        opponent_off: int = self.opponent_off
+
+        if source is None:
+            player_bar -= 1
+        else:
+            board_points[source] -= 1
+
+        if destination is None:
+            player_off += 1
+        else:
+            hit: bool = True if board_points[destination] == -1 else False
+            if hit:
+                board_points[destination] = 1
+                opponent_bar += 1
+            else:
+                board_points[destination] += 1
+
+        return Position(
+            tuple(board_points), player_bar, player_off, opponent_bar, opponent_off
+        )
+
+    def swap_players(self) -> "Position":
+        return Position(
+            tuple(map(lambda n: -n, self.board_points[::-1])),
+            self.opponent_bar,
+            self.opponent_off,
+            self.player_bar,
+            self.player_off,
+        )
+
+    def encode(self) -> str:
+        """Encode the position and return a position ID.
+
+        >>> position = Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2), player_bar=0, player_off=0, opponent_bar=0, opponent_off=0)
+        >>> position.encode()
+        '4HPwATDgc/ABMA'
+        """
+        player_points, opponent_points = _unmerge_points(self.board_points)
+        checkers: Tuple[int, ...] = (
+            opponent_points + (self.opponent_bar,) + player_points + (self.player_bar,)
+        )
+
+        position_key: str = _key_from_checkers(checkers)
+
+        position_id: str = _id_from_key(position_key)
+
+        return position_id
+
+
+def _unmerge_points(
+    board_points: Tuple[int, ...]
+) -> Tuple[Tuple[int, ...], Tuple[int, ...]]:
+    """Return player and opponent board positions starting from their respective ace points."""
+    player: Tuple[int, ...] = tuple(
+        map(
+            lambda n: 0 if n < 0 else n,
+            board_points,
+        )
+    )
+    opponent: Tuple[int, ...] = tuple(
+        map(
+            lambda n: 0 if n > 0 else -n,
+            board_points[::-1],
+        )
+    )
+    return player, opponent
+
+
+def _key_from_checkers(checkers: Tuple[int, ...]) -> str:
+    """Return a position key (bit string)."""
+    return "".join("1" * n + "0" for n in checkers).ljust(80, "0")
+
+
+def _id_from_key(position_key: str) -> str:
+    """Encode the position key and return the ID."""
+    byte_strings: Tuple[str, ...] = tuple(
+        position_key[i : i + 8][::-1] for i in range(0, len(position_key), 8)
+    )
+    position_bytes: bytes = struct.pack("10B", *(int(b, 2) for b in byte_strings))
+    return base64.b64encode(position_bytes).decode()[:-2]
+
+
+def decode(position_id: str) -> Position:
+    """Decode a position ID and return a Position.
+
+    >>> decode('4HPwATDgc/ABMA')
+    Position(board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2), player_bar=0, player_off=0, opponent_bar=0, opponent_off=0)
+    """
+    position_key: str = _key_from_id(position_id)
+
+    checkers: Tuple[int, ...] = _checkers_from_key(position_key)
+
+    player_points: Tuple[int, ...] = checkers[25:49]
+    opponent_points: Tuple[int, ...] = checkers[:24]
+    board_points: Tuple[int, ...] = _merge_points(player_points, opponent_points)
+
+    player_bar: int = checkers[49]
+    player_off: int = abs(15 - sum(player_points) - player_bar)
+
+    opponent_bar: int = checkers[24]
+    opponent_off: int = abs(15 - sum(opponent_points) - abs(opponent_bar))
+
+    return Position(
+        board_points=board_points,
+        player_bar=player_bar,
+        player_off=player_off,
+        opponent_bar=opponent_bar,
+        opponent_off=opponent_off,
+    )
+
+
+def _key_from_id(position_id: str) -> str:
+    """Decode the the position ID and return the key (bit string)."""
+    position_bytes: bytes = base64.b64decode(position_id + "==")
+    position_key: str = "".join([format(b, "08b")[::-1] for b in position_bytes])
+    return position_key
+
+
+def _checkers_from_key(position_key: str) -> Tuple[int, ...]:
+    """Return a list of checkers."""
+    return tuple(sum(int(n) for n in pos) for pos in position_key.split("0")[:50])
+
+
+def _merge_points(
+    player: Tuple[int, ...], opponent: Tuple[int, ...]
+) -> Tuple[int, ...]:
+    """Merge player and opponent board positions and return the combined points."""
+    return tuple(
+        i + j for i, j in zip(player, tuple(map(lambda n: -n, opponent[::-1])))
+    )

backgammon-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

backgammon-1.0.0/setup.py

@@ -0,0 +1,36 @@
+# Copyright 2019 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from setuptools import setup, find_packages
+
+with open("README.rst", encoding="utf-8") as f:
+    long_description = f.read()
+
+setup(
+    name="backgammon",
+    version="1.0.0",
+    author="Softwerks",
+    author_email="info@softwerks.com",
+    description="Backgammon engine for the Backgammon Network.",
+    long_description=long_description,
+    long_description_content_type="text/x-rst",
+    url="https://github.com/softwerks/backgammon",
+    packages=find_packages(),
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.7",
+)

backgammon-1.0.0/tests/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2021 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

backgammon-1.0.0/tests/test_backgammon.py

@@ -0,0 +1,414 @@
+# Copyright 2021 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+from unittest import mock
+
+from backgammon import backgammon
+from backgammon.backgammon import Play, Move
+from backgammon.position import Position
+
+
+class TestBackgammon(unittest.TestCase):
+    # fmt: off
+    def test_enter(self):
+        # -----19-20-21-22-23-24-+
+        # |   | O  O  O  O  O  O |
+        # |   | O  O  O  O  O  O |
+        # |   |                  |
+        # |BAR|      (5, 4)      |
+        # | X |                  |
+        self.assertEqual(
+            backgammon.Backgammon("27YBAAAAACAAAA", "cInyAAAAAAAE").generate_plays(),
+            [],
+        )
+
+        # -----19-20-21-22-23-24-+
+        # |   | O     O  O  O  O |
+        # |   | O        O  O  O |
+        # |   |                  |
+        # |BAR|      (5, 4)      |
+        # | X |                  |
+        self.assertEqual(
+            backgammon.Backgammon("2zIAAAAAAAQAAA", "cInyAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=4, source=None, destination=20),
+                        Move(pips=5, source=20, destination=15),
+                    ),
+                    position=Position(
+                        board_points=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, -2, 0, 0, -2, -2, -2),
+                        player_bar=0,
+                        player_off=14,
+                        opponent_bar=1,
+                        opponent_off=6,
+                    ),
+                ),
+                Play(
+                    moves=(
+                        Move(pips=5, source=None, destination=19),
+                        Move(pips=4, source=19, destination=15),
+                    ),
+                    position=Position(
+                        board_points=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, -2, 0, -1, -2, -2, -2),
+                        player_bar=0,
+                        player_off=14,
+                        opponent_bar=0,
+                        opponent_off=6,
+                    ),
+                ),
+            ],
+        )
+
+    def test_bear_off(self):
+        # |      (4, 3)
+        # |       X  X     O |
+        # |       X  X     O |
+        # --6--5--4--3--2--1-+
+        self.assertEqual(
+            backgammon.Backgammon("AACAYQMAAAAAAA", "cAnuAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=4, source=3, destination=None),
+                        Move(pips=3, source=2, destination=None),
+                    ),
+                    position=Position(
+                        board_points=(-2, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+                        player_bar=0,
+                        player_off=13,
+                        opponent_bar=0,
+                        opponent_off=13,
+                    ),
+                )
+            ],
+        )
+
+        # |      (4, 2)
+        # |             X  O |
+        # |       X     X  O |
+        # --6--5--4--3--2--1-+
+        self.assertEqual(
+            backgammon.Backgammon("AACAMQEAAAAAAA", "cAnqAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=2, source=3, destination=1),
+                        Move(pips=4, source=1, destination=None),
+                    ),
+                    position=Position(
+                        board_points=(-2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+                        player_bar=0,
+                        player_off=13,
+                        opponent_bar=0,
+                        opponent_off=13,
+                    ),
+                ),
+                Play(
+                    moves=(
+                        Move(pips=4, source=3, destination=None),
+                        Move(pips=2, source=1, destination=None),
+                    ),
+                    position=Position(
+                        board_points=(-2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+                        player_bar=0,
+                        player_off=14,
+                        opponent_bar=0,
+                        opponent_off=13,
+                    ),
+                ),
+            ],
+        )
+
+        # |      (6, 4)
+        # |    X           O |
+        # |    X     X     O |
+        # --6--5--4--3--2--1-+
+        self.assertEqual(
+            backgammon.Backgammon("AACAIQMAAAAAAA", "cAnzAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=6, source=4, destination=None),
+                    ),
+                    position=Position(
+                        board_points=(-2, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+                        player_bar=0,
+                        player_off=13,
+                        opponent_bar=0,
+                        opponent_off=13,
+                    ),
+                )
+            ],
+        )
+
+        # |      (6, 4)
+        # |    X           O |
+        # | X  X     X     O |
+        # --6--5--4--3--2--1-+
+        self.assertEqual(
+            backgammon.Backgammon("AACAIQsAAAAAAA", "cAnzAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=4, source=5, destination=1),
+                        Move(pips=6, source=4, destination=None),
+                    ),
+                    position=Position(
+                        board_points=(-2, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
+                        player_bar=0,
+                        player_off=12,
+                        opponent_bar=0,
+                        opponent_off=13,
+                    ),
+                )
+            ],
+        )
+
+    def test_move(self):
+        # +13-14-15-16-17-18------19-20-21-22-23-24-+
+        # |             O  O |   | O  O  O  O     X |
+        # |             O  O |   | O  O  O  O       |
+        # |                O |   | O  O             |
+        # |                  |   |                  |
+        # |                  |   |                  |
+        # |                  |BAR|      (6, 6)      |
+        # |                  |   |                X |
+        # |                  |   |                X |
+        # |                  |   |             X  X |
+        # |                  |   |    X  X  X  X  X |
+        # |                  |   |    X  X  X  X  X |
+        # +12-11-10--9--8--7-------6--5--4--3--2--1-+
+        self.assertEqual(
+            backgammon.Backgammon("bHc3AADfbQMAIA", "cAn7AAAAAAAE").generate_plays(),
+            [],
+        )
+
+        # -19-20-21-22-23-24-+
+        # | O     O  X  X  X |
+        # |       O  X       |
+        # |          X       |
+        # |      (1, 1)      |
+        self.assertEqual(
+            backgammon.Backgammon("mAAAAAAArgAAAA", "cInkAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=1, source=22, destination=21),
+                        Move(pips=1, source=23, destination=22),
+                        Move(pips=1, source=22, destination=21),
+                    ),
+                    position=Position(
+                        board_points=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, 0, -2, 5, 0, 0),
+                        player_bar=0,
+                        player_off=10,
+                        opponent_bar=0,
+                        opponent_off=12,
+                    ),
+                )
+            ],
+        )
+
+        # +13-14-15-16-17-18------19-20-21-22-23-24-+
+        # | O  O     O  O  X |   |       O  O  O  X |
+        # |    O     O  O    |   |       O     O    |
+        # |          O       |   |       O     O    |
+        # |                  |   |      (3, 2)      |
+        self.assertEqual(
+            backgammon.Backgammon("rsPOAgAAAAIBAA", "cImpAAAAAAAE").generate_plays(),
+            [
+                Play(
+                    moves=(
+                        Move(pips=3, source=17, destination=14),
+                        Move(pips=2, source=14, destination=12),
+                    ),
+                    position=Position(
+                        board_points=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, -2, 0, -3, -2, 0, 0, 0, -3, -1, -3, 1),
+                        player_bar=0,
+                        player_off=13,
+                        opponent_bar=1,
+                        opponent_off=0,
+                    ),
+                ),
+                Play(
+                    moves=(
+                        Move(pips=3, source=17, destination=14),
+                        Move(pips=2, source=23, destination=21),
+                    ),
+                    position=Position(
+                        board_points=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -2, 1, -3, -2, 0, 0, 0, -3, 1, -3, 0),
+                        player_bar=0,
+                        player_off=13,
+                        opponent_bar=1,
+                        opponent_off=0,
+                    ),
+                ),
+                Play(
+                    moves=(
+                        Move(pips=2, source=23, destination=21),
+                        Move(pips=3, source=21, destination=18),
+                    ),
+                    position=Position(
+                        board_points=(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1, -2, 0, -3, -2, 1, 1, 0, -3, 0, -3, 0),
+                        player_bar=0,
+                        player_off=13,
+                        opponent_bar=1,
+                        opponent_off=0,
+                    ),
+                ),
+            ],
+        )
+    # fmt: on
+
+    @mock.patch("random.SystemRandom.randrange", side_effect=[3, 4])
+    def test_start(self, randrange_mock):
+        self.assertEqual(
+            backgammon.Backgammon().start().encode(), "4HPwATDgc/ABMA:cIlxAAAAAAAA"
+        )
+
+    @mock.patch("random.SystemRandom.randrange", side_effect=[3, 4])
+    def test_roll(self, randrange_mock):
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPwATDgc/ABMA", "MAAOAAAAAAAA").roll()
+
+        self.assertEqual(backgammon.Backgammon().roll(), (3, 4))
+
+    @mock.patch("random.SystemRandom.randrange", side_effect=[3, 3, 4, 3, 3, 4])
+    def test_first_roll(self, randrange_mock):
+        p0: backgammon.Backgammon = backgammon.Backgammon()
+        self.assertEqual(p0.first_roll(), (4, 3))
+        self.assertEqual(p0.encode(), "4HPwATDgc/ABMA:MAAOAAAAAAAA")
+
+        p1: backgammon.Backgammon = backgammon.Backgammon()
+        self.assertEqual(p1.first_roll(), (3, 4))
+        self.assertEqual(p1.encode(), "4HPwATDgc/ABMA:cIgRAAAAAAAA")
+
+    @mock.patch("random.SystemRandom.randrange", side_effect=[5, 4, 3, 4, 4, 1])
+    def test_play(self, randrange_mock):
+        self.assertEqual(
+            backgammon.Backgammon("4NvBEQiYz+ABAw", "cAlqAAAAAAAE")
+            .play(((12, 8), (12, 10)))
+            .encode(),
+            "mM+SAQPg28EBRA:MAFgAAAAAAAA",
+        )
+
+        self.assertEqual(
+            backgammon.Backgammon("CwAAiAIAAAAAAA", "cAluAAAAAAAE")
+            .play(((3, None), (2, None)))
+            .encode(),
+            "4HPwATDgc/ABMA:MIFyAAAACAAA",
+        )
+
+        self.assertEqual(
+            backgammon.Backgammon("2+4FAEAhAAAAAA", "cAlvAAAAAAAE")
+            .play(((4, None), (0, None)))
+            .encode(),
+            "2+4FAEAAAAAAAA:cApvAAAAGAAA",
+        )
+
+        self.assertEqual(
+            backgammon.Backgammon("2+4FAAQhAAAAAA", "cAlvAAAAAAAE")
+            .play(((4, None), (0, None)))
+            .encode(),
+            "2+4FAAQAAAAAAA:cApvAAAAGAAA",
+        )
+
+        self.assertEqual(
+            backgammon.Backgammon("2+4NAAAhAAAAAA", "cAlvAAAAAAAE")
+            .play(((4, None), (0, None)))
+            .encode(),
+            "4HPwATDgc/ABMA:8IlxAAAAEAAA",
+        )
+
+        self.assertEqual(
+            backgammon.Backgammon("XwAAgAEAAAAAAA", "cIltACAAAAAA")
+            .play(((0, None), (0, None)))
+            .encode(),
+            "4HPwATDgc/ABMA:MAFmACAACAAA",
+        )
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPwATDgc/ABMA", "cAlqAAAAAAAE").play(
+                ((12, 8), (19, 17))
+            )
+
+    def test_double(self):
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPwATDgc/ABMA", "cInxABAAAAAA").double()
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPhASLgc/ABMA", "EQHgAAAAAAAA").double()
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPhASLgc/ABMA", "MBngAAAAAAAE").double()
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPhASLgc/ABMA", "MAHgAGAAKAAA").double()
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPhASLgc/ABMA", "8AmgAEAAGAAA").double()
+
+        self.assertEqual(
+            backgammon.Backgammon("0PPgATDgc+EBIg", "UQngAAAAAAAA").double().encode(),
+            "0PPgATDgc+EBIg:URHgAAAAAAAA",
+        )
+
+    def test_accept_double(self):
+        self.assertEqual(
+            backgammon.Backgammon("4HPhASLgc/ABMA", "MBngAAAAAAAE")
+            .accept_double()
+            .encode(),
+            "4HPhASLgc/ABMA:EQHgAAAAAAAA",
+        )
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPhASLgc/ABMA", "MAHgAAAAAAAA").accept_double()
+
+    @mock.patch("random.SystemRandom.randrange", side_effect=[3, 4])
+    def test_reject_double(self, randrange_mock):
+        self.assertEqual(
+            backgammon.Backgammon("4HPhASLgc/ABMA", "MBngAAAAAAAE")
+            .reject_double()
+            .encode(),
+            "4HPwATDgc/ABMA:cInxABAAAAAA",
+        )
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("4HPhASLgc/ABMA", "MAHgAAAAAAAA").reject_double()
+
+    def test_skip(self):
+        self.assertEqual(
+            backgammon.Backgammon("ZgAAAAAAIAAAAA", "cAnqAAAAAAAE").skip().encode(),
+            "AAAAmQEAAAAAAA:MAHgAAAAAAAA",
+        )
+
+        with self.assertRaises(backgammon.BackgammonError):
+            backgammon.Backgammon("MgAAAAAAEAAAAA", "cAnqAAAAAAAE").skip()
+
+    def test_end_turn(self):
+        self.assertEqual(
+            backgammon.Backgammon("ywEXAIGDAQEMAA", "MIGxABAAEAAA").end_turn().encode(),
+            "OBgQwJYDLgACAA:cAmgABAAEAAA",
+        )
+
+    def test_encode(self):
+        self.assertEqual(
+            backgammon.Backgammon("4HPwATDgc/ABMA", "cAgAAAAAAAAA").encode(),
+            "4HPwATDgc/ABMA:cAgAAAAAAAAA",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

backgammon-1.0.0/tests/test_match.py

@@ -0,0 +1,106 @@
+# Copyright 2021 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import unittest
+
+from backgammon import match
+
+
+class TestMatch(unittest.TestCase):
+    def test_swap_players(self):
+        self.assertEqual(
+            match.decode("cImxABAAEAAA").swap_players(), match.decode("MIGxABAAEAAA")
+        )
+
+    def test_swap_turn(self):
+        self.assertEqual(
+            match.decode("cImxABAAEAAA").swap_turn(), match.decode("cIGxABAAEAAA")
+        )
+
+    def test_reset_dice(self):
+        self.assertEqual(
+            match.decode("cImxABAAEAAA").reset_dice(), match.decode("cAmgABAAEAAA")
+        )
+
+    def test_reset_cube(self):
+        self.assertEqual(
+            match.decode("QYmxABAAEAAA").reset_cube(), match.decode("cImxABAAEAAA")
+        )
+
+    def test_drop_cube(self):
+        self.assertEqual(
+            match.decode("cBFgABAACAAA").drop_cube(), match.decode("cAFgABAAEAAA")
+        )
+        self.assertEqual(
+            match.decode("ARlgABAAEAAA").drop_cube(), match.decode("AQxgADAAEAAA")
+        )
+
+    def test_update_score(self):
+        self.assertEqual(
+            match.decode("QYkqASAAIAAA").update_score(1), match.decode("QYkqASAAMAAA")
+        )
+        self.assertEqual(
+            match.decode("MIFlABAAEAAA").update_score(3), match.decode("MIJlAEAAEAAA")
+        )
+        self.assertEqual(
+            match.decode("MIGqACAAGAAA").update_score(2), match.decode("sIGqAEAAGAAA")
+        )
+        self.assertEqual(
+            match.decode("QYnqACAAIAAA").update_score(1), match.decode("wYnqACAAMAAA")
+        )
+        self.assertEqual(
+            match.decode("MIGqACAAIAAA").update_score(2), match.decode("MIGqAEAAIAAA")
+        )
+
+    def test_encode(self):
+        self.assertEqual(
+            match.Match(
+                cube_value=2,
+                cube_holder=match.Player.ZERO,
+                player=match.Player.ONE,
+                crawford=False,
+                game_state=match.GameState.PLAYING,
+                turn=match.Player.ONE,
+                double=False,
+                resign=match.Resign.NONE,
+                dice=(5, 2),
+                length=9,
+                player_0_score=2,
+                player_1_score=4,
+            ).encode(),
+            "QYkqASAAIAAA",
+        )
+
+    def test_decode(self):
+        self.assertEqual(
+            match.decode("QYkqASAAIAAA"),
+            match.Match(
+                cube_value=2,
+                cube_holder=match.Player.ZERO,
+                player=match.Player.ONE,
+                crawford=False,
+                game_state=match.GameState.PLAYING,
+                turn=match.Player.ONE,
+                double=False,
+                resign=match.Resign.NONE,
+                dice=(5, 2),
+                length=9,
+                player_0_score=2,
+                player_1_score=4,
+            ),
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

backgammon-1.0.0/tests/test_position.py

@@ -0,0 +1,177 @@
+# Copyright 2021 Softwerks LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Tuple
+import unittest
+
+from backgammon import position
+
+
+class TestPosition(unittest.TestCase):
+    def test_enter(self):
+        # ----19-20-21-22-23-24-+
+        # |BAR| O  O  O     O  O |
+        # | X | O  O  O     O  O |
+        pos: position.Position = position.decode("m20AAAAAAAgAAA")
+        self.assertEqual(pos.enter(3), (position.decode("m20AAAAAAAEAAA"), 21))
+        self.assertEqual(pos.enter(2), (None, None))
+
+    def test_player_home(self):
+        # |             X    |
+        # |    X        X  O |
+        # | X  X  O     X  O |
+        # --6--5--4--3--2--1-+
+        pos: position.Position = position.decode("AAAQ41gAAAAAAA")
+        self.assertEqual(pos.player_home(), (0, 3, 0, 0, 2, 1))
+
+    def test_off(self):
+        # |             X  O |
+        # |    X  X     X  O |
+        # --6--5--4--3--2--1-+
+        pos: position.Position = position.decode("AACAMQUAAAAAAA")
+        self.assertEqual(pos.off(1, 2), (position.decode("AACAkQIAAAAAAA"), None))
+        self.assertEqual(pos.off(3, 4), (position.decode("AACAMQIAAAAAAA"), None))
+        self.assertEqual(pos.off(4, 6), (position.decode("AACAMQEAAAAAAA"), None))
+        self.assertEqual(pos.off(3, 2), (position.decode("AACAcQQAAAAAAA"), 1))
+        self.assertEqual(pos.off(3, 6), (None, None))
+
+    def test_move(self):
+        # -19-20-21-22-23-24-+
+        # | O     O  O  O  X |
+        # | O        O  O    |
+        pos: position.Position = position.decode("tgwAAAAAgAAAAA")
+        self.assertEqual(pos.move(23, 3), (position.decode("NgYAQAAAEAAAAA"), 20))
+        self.assertEqual(pos.move(23, 4), (position.decode("tgwAAAAACAAAAA"), 19))
+        self.assertEqual(pos.move(23, 5), (None, None))
+
+    def test_apply_move(self):
+        # -----19-20-21-22-23-24-+
+        # |BAR|    X        O  O |
+        # | X |                O |
+        pos: position.Position = position.decode("CwAAAACAIAAAAA")
+        self.assertEqual(pos.apply_move(None, 22), position.decode("AwAABACACAAAAA"))
+        self.assertEqual(pos.apply_move(None, 21), position.decode("CwAAAACABAAAAA"))
+        self.assertEqual(pos.apply_move(None, 19), position.decode("CwAAAACAAQAAAA"))
+        # | X        O       |
+        # | X        O  O  X |
+        # --6--5--4--3--2--1-+
+        pos: position.Position = position.decode("AABgEQwAAAAAAA")
+        self.assertEqual(pos.apply_move(5, 3), position.decode("AABgEQkAAAAAAA"))
+        self.assertEqual(pos.apply_move(5, 1), position.decode("AABgVAgAAAAAAA"))
+        self.assertEqual(pos.apply_move(5, 0), position.decode("AABgMQgAAAAAAA"))
+        self.assertEqual(pos.apply_move(5, None), position.decode("AABgEQQAAAAAAA"))
+
+    def test_swap_players(self):
+        # +13-14-15-16-17-18------19-20-21-22-23-24-+
+        # | O  O     X       |   |       O     O  O |
+        # |    O             |   |       O        O |
+        # |    O             |   |       O          |
+        # |                  |   |                  |
+        # |                  |BAR|       X          |
+        # |          X       | X |       X          |
+        # |          X       | X |       X     O    |
+        # +12-11-10--9--8--7-------6--5--4--3--2--1-+
+        pos: position.Position = position.decode("ywEXAIGDAQEMAA")
+        self.assertEqual(pos.swap_players(), position.decode("OBgQwJYDLgACAA"))
+
+    # fmt: off
+
+    def test_encode(self):
+        pos: position.Position = position.Position(
+            board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2),
+            player_bar=0,
+            player_off=0,
+            opponent_bar=0,
+            opponent_off=0,
+        )
+        self.assertEqual(pos.encode(), "4HPwATDgc/ABMA")
+
+    def test_unmerge_points(self):
+        player: Tuple[int, ...]
+        opponent: Tuple[int, ...]
+
+        board_points: Tuple[int, ...] = (-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2)
+        player, opponent = position._unmerge_points(board_points)
+
+        self.assertEqual(
+            player,
+            (0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2),
+        )
+        self.assertEqual(
+            opponent,
+            (0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2),
+        )
+
+    def test_key_from_checkers(self):
+        unmerged_points: Tuple[int, ...] = (0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2)
+        bar: Tuple[int, ...] = (0,)
+
+        self.assertEqual(
+            position._key_from_checkers(unmerged_points + bar + unmerged_points + bar),
+            "00000111110011100000111110000000000011000000011111001110000011111000000000001100",
+        )
+
+    def test_id_from_key(self):
+        self.assertEqual(
+            position._id_from_key(
+                "00000111110011100000111110000000000011000000011111001110000011111000000000001100"
+            ),
+            "4HPwATDgc/ABMA",
+        )
+
+    def test_decode(self):
+        self.assertEqual(
+            position.decode("4HPwATDgc/ABMA"),
+            position.Position(
+                board_points=(-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2),
+                player_bar=0,
+                player_off=0,
+                opponent_bar=0,
+                opponent_off=0,
+            ),
+        )
+
+    def test_key_from_id(self):
+        self.assertEqual(
+            position._key_from_id("4HPwATDgc/ABMA"),
+            "00000111110011100000111110000000000011000000011111001110000011111000000000001100",
+        )
+
+    def test_checkers_from_key(self):
+        self.assertEqual(
+            position._checkers_from_key(
+                "00000111110011100000111110000000000011000000011111001110000011111000000000001100"
+            ),
+            (
+                0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+                0,
+                0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2,
+                0,
+            ),
+        )
+
+    def test_merge_points(self):
+        self.assertEqual(
+            position._merge_points(
+                (0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2),
+                (0, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2),
+            ),
+            (-2, 0, 0, 0, 0, 5, 0, 3, 0, 0, 0, -5, 5, 0, 0, 0, -3, 0, -5, 0, 0, 0, 0, 2),
+        )
+
+    # fmt: on
+
+
+if __name__ == "__main__":
+    unittest.main()