fix pysol --deal 1/24/1000.

Low ms deals without the ms prefix caused an error.

pysollib/game.py

@@ -22,12 +22,13 @@
 # ---------------------------------------------------------------------------
 
 
-# imports
 import math
 import time
 import traceback
 from pickle import Pickler, Unpickler, UnpicklingError
 
+from pysol_cards.cards import ms_rearrange
+
 from pysollib.gamedb import GI
 from pysollib.help import help_about
 from pysollib.hint import DefaultHint
@@ -167,6 +168,93 @@ def _updateStatus_process_key_val(tb, sb, k, v):
     raise AttributeError(k)
 
 
+def _stats__is_perfect(stats):
+    """docstring for _stats__is_perfect"""
+    return (stats.undo_moves == 0 and
+            stats.goto_bookmark_moves == 0 and
+            # stats.quickplay_moves == 0 and
+            stats.highlight_piles == 0 and
+            stats.highlight_cards == 0 and
+            stats.shuffle_moves == 0)
+
+
+def _highlightCards__calc_item(canvas, delta, cw, ch, s, c1, c2, color):
+    assert c1 in s.cards and c2 in s.cards
+    tkraise = False
+    if c1 is c2:
+        # highlight single card
+        sx0, sy0 = s.getOffsetFor(c1)
+        x1, y1 = s.getPositionFor(c1)
+        x2, y2 = x1, y1
+        if c1 is s.cards[-1]:
+            # last card in the stack (for Pyramid-like games)
+            tkraise = True
+    else:
+        # highlight pile
+        if len(s.CARD_XOFFSET) > 1:
+            sx0 = 0
+        else:
+            sx0 = s.CARD_XOFFSET[0]
+        if len(s.CARD_YOFFSET) > 1:
+            sy0 = 0
+        else:
+            sy0 = s.CARD_YOFFSET[0]
+        x1, y1 = s.getPositionFor(c1)
+        x2, y2 = s.getPositionFor(c2)
+    if sx0 != 0 and sy0 == 0:
+        # horizontal stack
+        y2 += ch
+        if c2 is s.cards[-1]:  # top card
+            x2 += cw
+        else:
+            if sx0 > 0:
+                # left to right
+                x2 += sx0
+            else:
+                # right to left
+                x1 += cw
+                x2 += cw + sx0
+    elif sx0 == 0 and sy0 != 0:
+        # vertical stack
+        x2 += cw
+        if c2 is s.cards[-1]:  # top card
+            y2 += ch
+        else:
+            if sy0 > 0:
+                # up to down
+                y2 = y2 + sy0
+            else:
+                # down to up
+                y1 += ch
+                y2 += ch + sy0
+    else:
+        x2 += cw
+        y2 += ch
+        tkraise = True
+    # print c1, c2, x1, y1, x2, y2
+    x1, x2 = x1-delta[0], x2+delta[1]
+    y1, y2 = y1-delta[2], y2+delta[3]
+    if TOOLKIT == 'tk':
+        r = MfxCanvasRectangle(canvas, x1, y1, x2, y2,
+                               width=4, fill=None, outline=color)
+        if tkraise:
+            r.tkraise(c2.item)
+    elif TOOLKIT == 'kivy':
+        r = MfxCanvasRectangle(canvas, x1, y1, x2, y2,
+                               width=4, fill=None, outline=color)
+        if tkraise:
+            r.tkraise(c2.item)
+    elif TOOLKIT == 'gtk':
+        r = MfxCanvasRectangle(canvas, x1, y1, x2, y2,
+                               width=4, fill=None, outline=color,
+                               group=s.group)
+        if tkraise:
+            i = s.cards.index(c2)
+            for c in s.cards[i+1:]:
+                c.tkraise(1)
+    return r
+
+
 class Game(object):
     # for self.gstats.updated
     U_PLAY = 0
@@ -971,13 +1059,8 @@ class Game(object):
         # get a fresh copy of the original game-cards
         cards = list(self.cards)
         # init random generator
-        if isinstance(self.random, LCRandom31) and len(cards) == 52:
-            # FreeCell mode
-            fcards = []
-            for i in range(13):
-                for j in (0, 39, 26, 13):
-                    fcards.append(cards[i + j])
-            cards = fcards
+        if isinstance(self.random, LCRandom31):
+            cards = ms_rearrange(cards)
         self.random.reset()         # reset to initial seed
         # shuffle
         self.random.shuffle(cards)
@@ -1813,7 +1896,7 @@ class Game(object):
     #
 
     # game changed - i.e. should we ask the player to discard the game
-    def changed(self, restart=0):
+    def changed(self, restart=False):
         if self.gstats.updated < 0:
             return 0                    # already won or lost
         if self.gstats.loaded > 0:
@@ -1832,13 +1915,7 @@ class Game(object):
         if not won or self.stats.hints > 0 or self.stats.demo_moves > 0:
             # sorry, you lose
             return won, 0, self.U_LOST
-        if (self.stats.undo_moves == 0 and
-            self.stats.goto_bookmark_moves == 0 and
-            # self.stats.quickplay_moves == 0 and
-            self.stats.highlight_piles == 0 and
-            self.stats.highlight_cards == 0 and
-                self.stats.shuffle_moves == 0):
-            # perfect !
+        if _stats__is_perfect(self.stats):
             return won, 2, self.U_PERFECT
         return won, 1, self.U_WON
 
@@ -1892,17 +1969,17 @@ You have reached
     def checkForWin(self):
         won, status, updated = self.getWinStatus()
         if not won:
-            return 0
+            return False
         self.finishMove()       # just in case
         if self.preview:
-            return 1
+            return True
         if self.finished:
-            return 1
+            return True
         if self.demo:
             return status
         if TOOLKIT == 'kivy':
             if not self.app.opt.display_win_message:
-                return 1
+                return True
             self.top.waitAnimation()
         if status == 2:
             top_msg = self.updateStats()
@@ -1959,7 +2036,7 @@ Congratulations, you did it !
                 strings=(_("&New game"), _("&Restart"), _("&Cancel")))
         self.updateMenus()
         if TOOLKIT == 'kivy':
-            return 1
+            return True
         if d.status == 0 and d.button == 0:
             # new game
             self.endGame()
@@ -1967,7 +2044,7 @@ Congratulations, you did it !
         elif d.status == 0 and d.button == 1:
             # restart game
             self.restartGame()
-        return 1
+        return True
 
     #
     # Game - subclass overridable methods (but usually not)
@@ -1975,10 +2052,8 @@ Congratulations, you did it !
 
     def isGameWon(self):
         # default: all Foundations must be filled
-        c = 0
-        for s in self.s.foundations:
-            c = c + len(s.cards)
-        return c == len(self.cards)
+        return sum([len(s.cards) for s in self.s.foundations]) == \
+            len(self.cards)
 
     def getFoundationDir(self):
         for s in self.s.foundations:
@@ -1988,16 +2063,10 @@ Congratulations, you did it !
 
     # determine the real number of player_moves
     def getPlayerMoves(self):
-        player_moves = self.stats.player_moves
-        # if self.moves.index > 0 and
-        # self.stats.demo_moves == self.moves.index:
-        # player_moves = 0
-        return player_moves
+        return self.stats.player_moves
 
     def updateTime(self):
-        if self.finished:
-            return
-        if self.pause:
+        if self.finished or self.pause:
             return
         t = time.time()
         d = t - self.stats.update_time
@@ -2122,80 +2191,9 @@ Congratulations, you did it !
         cw, ch = self.app.images.getSize()
         items = []
         for s, c1, c2, color in info:
-            assert c1 in s.cards and c2 in s.cards
-            tkraise = False
-            if c1 is c2:
-                # highlight single card
-                sx0, sy0 = s.getOffsetFor(c1)
-                x1, y1 = s.getPositionFor(c1)
-                x2, y2 = x1, y1
-                if c1 is s.cards[-1]:
-                    # last card in the stack (for Pyramid-like games)
-                    tkraise = True
-            else:
-                # highlight pile
-                if len(s.CARD_XOFFSET) > 1:
-                    sx0 = 0
-                else:
-                    sx0 = s.CARD_XOFFSET[0]
-                if len(s.CARD_YOFFSET) > 1:
-                    sy0 = 0
-                else:
-                    sy0 = s.CARD_YOFFSET[0]
-                x1, y1 = s.getPositionFor(c1)
-                x2, y2 = s.getPositionFor(c2)
-            if sx0 != 0 and sy0 == 0:
-                # horizontal stack
-                y2 += ch
-                if c2 is s.cards[-1]:  # top card
-                    x2 += cw
-                else:
-                    if sx0 > 0:
-                        # left to right
-                        x2 += sx0
-                    else:
-                        # right to left
-                        x1 += cw
-                        x2 += cw + sx0
-            elif sx0 == 0 and sy0 != 0:
-                # vertical stack
-                x2 += cw
-                if c2 is s.cards[-1]:  # top card
-                    y2 += ch
-                else:
-                    if sy0 > 0:
-                        # up to down
-                        y2 = y2 + sy0
-                    else:
-                        # down to up
-                        y1 += ch
-                        y2 += ch + sy0
-            else:
-                x2 += cw
-                y2 += ch
-                tkraise = True
-            # print c1, c2, x1, y1, x2, y2
-            x1, x2 = x1-delta[0], x2+delta[1]
-            y1, y2 = y1-delta[2], y2+delta[3]
-            if TOOLKIT == 'tk':
-                r = MfxCanvasRectangle(self.canvas, x1, y1, x2, y2,
-                                       width=4, fill=None, outline=color)
-                if tkraise:
-                    r.tkraise(c2.item)
-            elif TOOLKIT == 'kivy':
-                r = MfxCanvasRectangle(self.canvas, x1, y1, x2, y2,
-                                       width=4, fill=None, outline=color)
-                if tkraise:
-                    r.tkraise(c2.item)
-            elif TOOLKIT == 'gtk':
-                r = MfxCanvasRectangle(self.canvas, x1, y1, x2, y2,
-                                       width=4, fill=None, outline=color,
-                                       group=s.group)
-                if tkraise:
-                    i = s.cards.index(c2)
-                    for c in s.cards[i+1:]:
-                        c.tkraise(1)
-            items.append(r)
+            items.append(
+                _highlightCards__calc_item(
+                    self.canvas, delta, cw, ch, s, c1, c2, color))
         if not items:
             return 0
         self.canvas.update_idletasks()

pysollib/pysolrandom.py

@@ -34,7 +34,7 @@ except ImportError:
         "You need to install " +
         "https://pypi.python.org/pypi/random2 using pip or similar.")
 
-from pysol_cards.random import RandomBase  # noqa: I100
+from pysol_cards.random_base import RandomBase  # noqa: I100
 
 
 # ************************************************************************
@@ -277,7 +277,7 @@ PysolRandom = MTRandom
 
 def _match_ms(s):
     """match an ms based seed string."""
-    return re.match(r"ms([0-9]+)\n?\Z", s)
+    return re.match(r"ms([0-9]+)\n?\Z", str(s))
 
 
 # construct Random from seed string

tests/lib/pysol_tests/ms_deals1/__init__.py

@@ -53,6 +53,8 @@
 # imports
 import unittest
 
+from pysol_cards.cards import ms_rearrange
+
 # So the localpaths will be overrided.
 from pysollib.pysolrandom import LCRandom31, constructRandom, \
         random__long2str, random__str2long
@@ -244,13 +246,8 @@ def flip_card(card_str, flip):
 
 def shuffle(orig_cards, rand):
     shuffled_cards = list(orig_cards)
-    if isinstance(rand, LCRandom31) and len(shuffled_cards) == 52:
-        # FreeCell mode
-        fcards = []
-        for i in range(13):
-            for j in (0, 39, 26, 13):
-                fcards.append(shuffled_cards[i + j])
-        shuffled_cards = fcards
+    if isinstance(rand, LCRandom31):
+        shuffled_cards = ms_rearrange(shuffled_cards)
     # rand.shuffle works in place
     rand.shuffle(shuffled_cards)
     return shuffled_cards