Delete backgammon-1.0.0

backgammon-1.0.0/LICENSE

@@ -1,201 +0,0 @@
-                                 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

@@ -1,79 +0,0 @@
-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

@@ -1,61 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1 +0,0 @@
-

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

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

backgammon-1.0.0/backgammon/__init__.py

@@ -1,15 +0,0 @@
-# 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

@@ -1,109 +0,0 @@
-# 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

@@ -1,383 +0,0 @@
-# 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

@@ -1,177 +0,0 @@
-# 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

@@ -1,214 +0,0 @@
-# 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

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

backgammon-1.0.0/setup.py

@@ -1,36 +0,0 @@
-# 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

@@ -1,13 +0,0 @@
-# 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

@@ -1,414 +0,0 @@
-# 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

@@ -1,106 +0,0 @@
-# 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

@@ -1,177 +0,0 @@
-# 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()