+ 1 new game

+ new layout attribute: TEXT_HEIGHT


git-svn-id: file:///home/shlomif/Backup/svn-dumps/PySolFC/svnsync-repos/pysolfc/PySolFC/trunk@13 efabe8c0-fbe8-4139-b769-b5e6d273206e

pysollib/app.py

@@ -195,7 +195,7 @@ class Options:
         self.splashscreen = True
         self.sticky_mouse = False
         self.negative_bottom = False
-        self.randomize_place = True
+        self.randomize_place = False
         self.cache_carsets = True
         # defaults & constants
         self.setDefaults()
@@ -228,12 +228,12 @@ class Options:
             CSI.TYPE_DASHAVATARA_GANJIFA: ("Dashavatara Ganjifa", ""),
             CSI.TYPE_TRUMP_ONLY: ("Matrix", ""),
         }
-        self.randomize_place = True
 
     # not changeable options
     def setConstants(self):
         self.win_animation = 1
         self.dragcursor = 1
+        self.randomize_place = False
 
     def copy(self):
         opt = Options()
@@ -826,8 +826,7 @@ class Application:
                   "joker07_50_774",
                   "joker08_50_774",
                   "joker11_100_774",
-                  "joker10_100",
+                  "joker10_100",):
-                  "pysol_40",):
             self.gimages.logos.append(self.dataloader.findImage(f, dir))
         dir = "images"
         ##for f in ("noredeal", "redeal",):
@@ -1143,10 +1142,7 @@ Please select a %s type %s.
         opt = unpickle(self.fn.opt)
         if opt:
             ##import pprint; pprint.pprint(opt.__dict__)
-            #cardset = self.opt.cardset
-            #cardset.update(opt.cardset)
             self.opt.__dict__.update(opt.__dict__)
-            #self.opt.cardset = cardset
         self.opt.setConstants()
 
     def loadStatistics(self):
@@ -1290,13 +1286,19 @@ Please select a %s type %s.
         return n
 
     def getGameSaveName(self, id):
-        n = self.getGameTitleName(id)
+        if os.path.supports_unicode_filenames: # new in python 2.3
+            return self.getGameTitleName(id)
+        gi = self.gdb.get(id)
+        n = gi.name
         if not n: return None
-        m = re.search(r"^(.*)([\[\(](\w+).*[\]\)])\s*$", n)
+##         m = re.search(r"^(.*)([\[\(](\w+).*[\]\)])\s*$", n)
-        if m:
+##         if m:
-            n = m.group(1) + "_" + m.group(2).lower()
+##             n = m.group(1) + "_" + m.group(2).lower()
         n = latin1_to_ascii(n)
-        return re.sub(r"[^\w\-]", "", n)
+        n = n.lower()
+        n = re.sub(r"[\s]", "_", n)
+        n = re.sub(r"[^\w]", "", n)
+        return n
 
     def getRandomGameId(self):
         return self.miscrandom.choice(self.gdb.getGamesIdSortedById())

pysollib/games/auldlangsyne.py

@@ -293,7 +293,7 @@ class Colorado(Game):
         l, s = Layout(self), self.s
 
         # set window
-        self.setSize(l.XM+10*l.XS, 3*l.YM+4*l.YS)
+        self.setSize(l.XM+10*l.XS, l.YM+4*l.YS+l.TEXT_HEIGHT)
 
         # create stacks
         x, y, = l.XS, l.YM

pysollib/games/beleagueredcastle.py

@@ -372,7 +372,7 @@ class Zerline(Game):
         # set window
         # (set size so that at least 13 cards are fully playable)
         w = max(3*l.XS, l.XS+playcards*l.XOFFSET)
-        self.setSize(l.XM+2*w+decks*l.XS, 4*l.YM + (rows/2+1)*l.YS)
+        self.setSize(l.XM+2*w+decks*l.XS, l.YM+l.TEXT_HEIGHT+(rows/2+1)*l.YS)
 
         # create stacks
         y = l.YM
@@ -389,7 +389,7 @@ class Zerline(Game):
         l.createText(stack, "ss")
         x = l.XM + w
         for j in range(decks):
-            y = 4*l.YM+l.YS
+            y = l.YM+l.TEXT_HEIGHT+l.YS
             for i in range(4):
                 s.foundations.append(SS_FoundationStack(x, y, self, i,
                                      base_rank=KING, dir=1, max_move=0, mod=13))
@@ -397,15 +397,15 @@ class Zerline(Game):
             x += l.XS
         x = l.XM
         for j in range(2):
-            y = 4*l.YM+l.YS
+            y = l.YM+l.TEXT_HEIGHT+l.YS
             for i in range(rows/2):
                 stack = RK_RowStack(x, y, self, max_move=1, max_accept=1, base_rank=QUEEN)
                 stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
                 s.rows.append(stack)
                 y += l.YS
-            x += l.XM + w +decks*l.XS
+            x += l.XM+w+decks*l.XS
 
-        l.setRegion(s.rows[:4], (-999, 4*l.YM+l.YS-l.CH/2, w-l.CW/2, 999999))
+        l.setRegion(s.rows[:4], (-999, l.YM+l.YS+l.TEXT_HEIGHT-l.CH/2, w-l.CW/2, 999999))
 
         # define stack-groups
         l.defaultStackGroups()

pysollib/games/braid.py

@@ -313,7 +313,7 @@ class Backbone(Game):
         l, s = Layout(self), self.s
 
         # set window
-        w, h = l.XM+(rows+2)*l.XS, max(l.YM+3*l.XS+10*l.YOFFSET, l.YM+2*l.YS+11*l.YOFFSET+20)
+        w, h = l.XM+(rows+2)*l.XS, max(l.YM+3*l.XS+10*l.YOFFSET, l.YM+2*l.YS+11*l.YOFFSET+l.TEXT_HEIGHT)
         self.setSize(w, h)
 
         # create stacks

pysollib/games/bristol.py

@@ -197,7 +197,7 @@ class Dover(Bristol):
 
         # set window
         max_rows = max(rows, self.gameinfo.decks*4)
-        w, h = 2*l.XM+l.XS+max_rows*l.XS, l.YM+20+5*l.YS
+        w, h = 2*l.XM+l.XS+max_rows*l.XS, l.YM+l.TEXT_HEIGHT+5*l.YS
         self.setSize(w, h)
 
         # create stacks
@@ -215,7 +215,7 @@ class Dover(Bristol):
 
         x, y = 2*l.XM+(max_rows-rows)*l.XS, l.YM+l.YS
         if text:
-            y += 20
+            y += l.TEXT_HEIGHT
         for i in range(rows):
             x += l.XS
             stack = self.RowStack_Class(x, y, self)
@@ -224,7 +224,7 @@ class Dover(Bristol):
         x, y, = l.XM, l.YM
         s.talon = self.Talon_Class(x, y, self)
         l.createText(s.talon, "s")
-        y += 20
+        y += l.TEXT_HEIGHT
         for i in range(3):
             y += l.YS
             s.reserves.append(self.ReserveStack_Class(x, y, self))

pysollib/games/calculation.py

@@ -114,12 +114,12 @@ class Calculation(Game):
 
     def createGame(self):
         # create layout
-        l, s = Layout(self), self.s
+        l, s = Layout(self, TEXT_HEIGHT=40), self.s
 
         # set window
         # (piles up to 20 cards are playable in default window size)
         h = max(2*l.YS, 20*l.YOFFSET)
-        self.setSize(5.5*l.XS+l.XM+200, l.YM + l.YS + 30 + h)
+        self.setSize(5.5*l.XS+l.XM+200, l.YM + l.YS + l.TEXT_HEIGHT + h)
 
         # create stacks
         x0 = l.XM + l.XS * 3 / 2
@@ -140,7 +140,7 @@ class Calculation(Game):
         self.texts.help = MfxCanvasText(self.canvas, x + l.XM, y + l.CH / 2, text=help,
                                         anchor="w", font=self.app.getFont("canvas_fixed"))
         x = x0
-        y = l.YM + l.YS + 30
+        y = l.YM + l.YS + l.TEXT_HEIGHT
         for i in range(4):
             s.rows.append(Calculation_RowStack(x, y, self, max_move=1, max_accept=1))
             x = x + l.XS
@@ -205,10 +205,10 @@ class BetsyRoss(Calculation):
 
     def createGame(self):
         # create layout
-        l, s = Layout(self), self.s
+        l, s = Layout(self, TEXT_HEIGHT=40), self.s
 
         # set window
-        self.setSize(5.5*l.XS+l.XM+200, l.YM + l.YS + 30 + 3*l.YS)
+        self.setSize(5.5*l.XS+l.XM+200, l.YM + l.YS + l.TEXT_HEIGHT + 3*l.YS)
 
         # create stacks
         x0 = l.XM + l.XS * 3 / 2
@@ -219,7 +219,7 @@ class BetsyRoss(Calculation):
             s.foundations.append(stack)
             x = x + l.XS
         x = x0
-        y = l.YM + l.YS + 30
+        y = l.YM + l.YS + l.TEXT_HEIGHT
         for i in range(4):
             stack = BetsyRoss_Foundation(x, y, self, base_rank=2*i+1, mod=13, dir=i+1,
                                         max_cards=12, max_move=0)

pysollib/games/canfield.py

@@ -119,7 +119,7 @@ class Canfield(Game):
                 yoffset = 5
         # (piles up to 20 cards are playable in default window size)
         h = max(3*l.YS, l.YS+self.INITIAL_RESERVE_CARDS*yoffset)
-        self.setSize(l.XM + (2+max(rows, 4*decks))*l.XS + l.XM, l.YM + l.YS + 20 + h)
+        self.setSize(l.XM + (2+max(rows, 4*decks))*l.XS + l.XM, l.YM + l.YS + l.TEXT_HEIGHT + h)
 
         # extra settings
         self.base_card = None
@@ -145,7 +145,7 @@ class Canfield(Game):
                 tx, ty = x + tx, y + ty + l.YM
             font = self.app.getFont("canvas_default")
             self.texts.info = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font)
-        x, y = l.XM, l.YM + l.YS + 20
+        x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT
         s.reserves.append(self.ReserveStack_Class(x, y, self))
         s.reserves[0].CARD_YOFFSET = yoffset
         x = l.XM + 2 * l.XS + l.XM
@@ -489,7 +489,7 @@ class LittleGate(Gate):
         self.setSize(w, h)
 
         # create stacks
-        y = 4*l.YM+l.YS
+        y = l.YM+l.YS+l.TEXT_HEIGHT
         for x in (l.XM, w-l.XS):
             stack = OpenStack(x, y, self, max_accept=0)
             stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
@@ -498,14 +498,14 @@ class LittleGate(Gate):
         for i in range(4):
             s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
             x += l.XS
-        x, y = int(l.XM+1.5*l.XS), 4*l.YM+l.YS
+        x, y = int(l.XM+1.5*l.XS), l.YM+l.YS+l.TEXT_HEIGHT
         for i in range(4):
             s.rows.append(AC_RowStack(x, y, self))
             x += l.XS
         s.talon = WasteTalonStack(l.XM, l.YM, self, max_rounds=1)
-        l.createText(s.talon, "s")
+        l.createText(s.talon, "ss")
         s.waste = WasteStack(l.XM+l.XS, l.YM, self)
-        l.createText(s.waste, "s")
+        l.createText(s.waste, "ss")
 
         # define stack-groups
         l.defaultStackGroups()
@@ -630,7 +630,7 @@ class Duke(Game):
         for i in range(4):
             s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
             x += l.XS
-        x0, y0, w = l.XM, 3*l.YM+l.YS, l.XS+2*l.XOFFSET
+        x0, y0, w = l.XM, l.YM+l.YS+l.TEXT_HEIGHT, l.XS+2*l.XOFFSET
         for i, j in ((0,0), (0,1), (1,0), (1,1)):
             x, y = x0+i*w, y0+j*l.YS
             stack = OpenStack(x, y, self, max_accept=0)

pysollib/games/diplomat.py

@@ -67,7 +67,7 @@ class Diplomat(Game):
         l, s = Layout(self), self.s
 
         # set window
-        self.setSize(l.XM+8*l.XS, l.YM+3*l.YS+12*l.YOFFSET+20)
+        self.setSize(l.XM+8*l.XS, l.YM+3*l.YS+12*l.YOFFSET+l.TEXT_HEIGHT)
 
         # create stacks
         x, y = l.XM, l.YM

pysollib/games/fortythieves.py

@@ -74,23 +74,22 @@ class FortyThieves(Game):
     def createGame(self, max_rounds=1, num_deal=1, rows=10, playcards=12, XCARDS=64, XOFFSET=None):
         # create layout
         if XOFFSET is None:
-            l, s = Layout(self, YBOTTOM=16), self.s
+            l, s = Layout(self), self.s
         else:
-            l, s = Layout(self, XOFFSET=XOFFSET, YBOTTOM=16), self.s
+            l, s = Layout(self, XOFFSET=XOFFSET), self.s
 
         # set window
         # (compute best XOFFSET - up to 64/72 cards can be in the Waste)
         decks = self.gameinfo.decks
-        if rows < 12:
+        maxrows = max(rows, 4*decks)
-            maxrows = max(rows, 4*decks+2)
+        if maxrows <= 12:
-        else:
+            maxrows += 1
-            maxrows = max(rows, 4*decks)
         w1, w2 = maxrows*l.XS+l.XM, 2*l.XS
         if w2 + XCARDS * l.XOFFSET > w1:
             l.XOFFSET = int((w1 - w2) / XCARDS)
         # (piles up to 12 cards are playable without overlap in default window size)
         h = max(2*l.YS, l.YS+(playcards-1)*l.YOFFSET)
-        self.setSize(w1, l.YM + l.YS + h + l.YS + l.YBOTTOM)
+        self.setSize(w1, l.YM + l.YS + h + l.YS + l.TEXT_HEIGHT)
 
         # create stacks
         x = l.XM + (maxrows - 4*decks) * l.XS / 2
@@ -104,7 +103,7 @@ class FortyThieves(Game):
             s.rows.append(self.RowStack_Class(x, y, self, max_move=self.ROW_MAX_MOVE))
             x = x + l.XS
         x = self.width - l.XS
-        y = self.height - l.YS - l.YBOTTOM
+        y = self.height - l.YS - l.TEXT_HEIGHT
         s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds, num_deal=num_deal)
         l.createText(s.talon, "s")
         if max_rounds > 1:
@@ -245,6 +244,11 @@ class Express(Limited):
         FortyThieves.createGame(self, rows=14, playcards=16, XCARDS=96)
 
 
+class Carnation(Limited):
+    def createGame(self):
+        FortyThieves.createGame(self, rows=16, playcards=20, XCARDS=120)
+
+
 # /***********************************************************************
 # // Deuces
 # ************************************************************************/
@@ -588,7 +592,7 @@ class FortunesFavor(Game):
 
         l, s = Layout(self), self.s
 
-        w, h = l.XM+7*l.XS, 2*l.YM+3*l.YS
+        w, h = l.XM+8*l.XS, 2*l.YM+3*l.YS
         self.setSize(w, h)
 
         x, y = l.XM+3*l.XS, l.YM
@@ -597,13 +601,13 @@ class FortunesFavor(Game):
             x += l.XS
         x, y = l.XM, l.YM
         s.talon = WasteTalonStack(x, y, self, max_rounds=1)
-        l.createText(s.talon, 's')
+        l.createText(s.talon, 'se')
-        y += l.YS+2*l.YM
+        y += l.YS
         s.waste = WasteStack(x, y, self)
-        l.createText(s.waste, 's')
+        l.createText(s.waste, 'se')
         y = 2*l.YM+l.YS
         for i in range(2):
-            x = l.XM+l.XS
+            x = l.XM+2*l.XS
             for j in range(6):
                 stack = SS_RowStack(x, y, self, max_move=1)
                 stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
@@ -826,3 +830,5 @@ registerGame(GameInfo(505, BigCourtyard, "Big Courtyard",
                       GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0, GI.SL_BALANCED))
 registerGame(GameInfo(506, Express, "Express",
                       GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))
+registerGame(GameInfo(514, Carnation, "Carnation",
+                      GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 4, 0, GI.SL_MOSTLY_SKILL))

pysollib/games/glenwood.py

@@ -104,32 +104,33 @@ class Glenwood(Game):
         l, s = Layout(self), self.s
 
         # set window
-        self.setSize(l.XM + 8*l.XS + l.XM, 3*l.YM + 5*l.YS)
+        self.setSize(2*l.XM + 6*l.XS, l.YM + l.TEXT_HEIGHT + 5*l.YS)
 
         # create stacks
         x, y = l.XM, l.YM
         s.talon = Glenwood_Talon(x, y, self, max_rounds=2, num_deal=1)
         l.createText(s.talon, "ss")
-        x = x + l.XS
+        x += l.XS
         s.waste = WasteStack(x, y, self)
         l.createText(s.waste, "ss")
+        x += l.XS+l.XM
         for i in range(4):
-            x = 2*l.XM + (i+2)*l.XS
             s.foundations.append(self.Foundation_Class(x, y, self, i, dir=1,
                                  mod=13, base_rank=ANY_RANK, max_move=0))
+            x += l.XS
 
-        tx, ty, ta, tf = l.getTextAttr(None, "se")
+        tx, ty, ta, tf = l.getTextAttr(None, "ss")
-        tx, ty = x + tx + l.XM, y + ty
+        tx, ty = x - l.XS + tx, y + ty
         font = self.app.getFont("canvas_default")
         self.texts.info = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font)
 
         for i in range(4):
             x = 2*l.XM + (i+2)*l.XS
-            y = 3*l.YM + l.YS
+            y = l.YM+l.TEXT_HEIGHT+l.YS
             s.rows.append(self.RowStack_Class(x, y, self, mod=13))
         for i in range(4):
             x = l.XM
-            y = 3*l.YM + (i+1)*l.YS
+            y = l.YM+l.TEXT_HEIGHT+(i+1)*l.YS
             stack = self.ReserveStack_Class(x, y, self)
             s.reserves.append(stack)
             stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0

pysollib/games/golf.py

@@ -131,10 +131,11 @@ class Golf(Game):
         l, s = Layout(self), self.s
 
         # set window
+        playcards = 5
         w1, w2 = 8*l.XS+l.XM, 2*l.XS
         if w2 + 52*l.XOFFSET > w1:
             l.XOFFSET = int((w1 - w2) / 52)
-        self.setSize(w1, 4*l.YS+l.YM)
+        self.setSize(w1, l.YM+3*l.YS+(playcards-1)*l.YOFFSET+l.TEXT_HEIGHT)
 
         # create stacks
         x, y = l.XM + l.XS / 2, l.YM

pysollib/games/gypsy.py

@@ -493,7 +493,7 @@ class Surprise(Gypsy):
         for i in range(8):
             s.foundations.append(SS_FoundationStack(x, y, self, suit=i/2))
             x += l.XS
-        x, y = l.XM, l.YM+l.YS+20
+        x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT
         for i in range(11):
             s.rows.append(KingAC_RowStack(x, y, self))
             x += l.XS

pysollib/games/klondike.py

@@ -553,12 +553,29 @@ class Jane(Klondike):
     Foundation_Class = StackWrapper(SS_FoundationStack, mod=13, base_rank=NO_RANK, min_cards=1)
     RowStack_Class = StackWrapper(AC_RowStack, mod=13, base_rank=NO_RANK)
 
-    def createGame(self, max_rounds=1, reserves=7, **layout):
+    def createGame(self, max_rounds=1, rows=7, reserves=7, playcards=16):
-        kwdefault(layout, texts=0)
+        l, s = Layout(self), self.s
-        l = apply(Klondike.createGame, (self, max_rounds), layout)
+        maxrows = max(rows, 7)
-        s = self.s
+        w = l.XM+maxrows*l.XS+l.XM+2*l.XS
-        h = max(self.height, l.YM+4*l.YS)
+        h = max(l.YM+2*l.YS+playcards*l.YOFFSET+l.TEXT_HEIGHT, l.YM+4*l.YS)
-        self.setSize(self.width + l.XM+2*l.XS, h)
+        self.setSize(w, h)
+
+        x, y = l.XM, l.YM
+        s.talon = self.Talon_Class(x, y, self, max_rounds=max_rounds)
+        l.createText(s.talon, 'ss')
+        x += l.XS
+        s.waste = WasteStack(l.XM+l.XS+40, l.YM, self)
+
+        x += 2*l.XS
+        for i in range(4):
+            s.foundations.append(self.Foundation_Class(x, y, self, suit=i))
+            x += l.XS
+
+        x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT
+        for i in range(rows):
+            s.rows.append(self.RowStack_Class(x, y, self))
+            x += l.XS
+
         x0, y = self.width - 2*l.XS, l.YM
         for i in range(reserves):
             x = x0 + ((i+1) & 1) * l.XS
@@ -571,11 +588,6 @@ class Jane(Klondike):
         ##self.setRegion(s.reserves, (x0-l.XM/2, -999, 999999, 999999), priority=1)
         l.defaultStackGroups()
         self.sg.dropstacks.append(s.talon)
-        x, y = l.XM, self.height - l.YM
-        # ???
-        #self.texts.info = MfxCanvasText(self.canvas, x, y, anchor="sw",
-        #                                font=self.app.getFont("canvas_default"))
-        l.createText(s.talon, 'ss')
 
     def startGame(self, flip=0, reverse=1):
         for i in range(1, len(self.s.rows)):
@@ -607,9 +619,6 @@ class AgnesBernauer(Jane):
     Talon_Class = AgnesBernauer_Talon
     Foundation_Class = StackWrapper(SS_FoundationStack, mod=13, base_rank=NO_RANK, max_move=0)
 
-    def createGame(self):
-        Jane.createGame(self, max_rounds=1, waste=0, texts=0)
-
     def startGame(self):
         Jane.startGame(self, flip=1)
 

pysollib/games/royalcotillion.py

@@ -429,7 +429,7 @@ class BritishConstitution(Game):
         x, y = l.XM, l.YM
         s.talon = WasteTalonStack(x, y, self, max_rounds=1)
         l.createText(s.talon, "s")
-        y += l.YS+2*l.YM
+        y += l.YS+l.TEXT_HEIGHT
         s.waste = WasteStack(x, y, self)
         l.createText(s.waste, "s")
 

pysollib/games/special/tarock.py

@@ -342,7 +342,7 @@ class ImperialTrumps(AbstractTarockGame):
 
         # Create rows
         x = l.XM
-        y = l.YM + int(round(l.YS * 1.25))
+        y = l.YM + l.YS + l.TEXT_HEIGHT
         for i in range(8):
             s.rows.append(TrumpWild_RowStack(x, y, self))
             x = x + l.XS
@@ -674,7 +674,6 @@ class Grasshopper(AbstractTarockGame):
 
     def createGame(self):
         l, s = Layout(self), self.s
-        font = self.app.getFont("canvas_default")
 
         # Set window size
         decks = self.gameinfo.decks
@@ -702,7 +701,7 @@ class Grasshopper(AbstractTarockGame):
 
         # Create reserve
         x = l.XM
-        y = l.YM * 3 + l.YS
+        y = l.YM + l.YS + l.TEXT_HEIGHT
         s.reserves.append(OpenStack(x, y, self))
         s.reserves[0].CARD_YOFFSET = (l.YOFFSET, yoffset)[decks == 2]
 
@@ -767,7 +766,7 @@ class Ponytail(Tarock_GameMethods, Braid):
 
         # set window
         # (piles up to 20 cards are playable - needed for Ponytail_PonytailStack)
-        h = max(5*l.YS + 30, l.YS+(self.BRAID_CARDS-1)*l.YOFFSET)
+        h = max(5*l.YS + l.TEXT_HEIGHT, l.YS+(self.BRAID_CARDS-1)*l.YOFFSET)
         self.setSize(10*l.XS+l.XM, l.YM + h)
 
         # extra settings

pysollib/games/sultan.py

@@ -49,7 +49,7 @@ class Sultan(Game):
         l, s = Layout(self), self.s
 
         # set window
-        w, h = 3*l.XM+5*l.XS, 3*l.YM+4*l.YS
+        w, h = 3*l.XM+5*l.XS, l.YM+4*l.YS+l.TEXT_HEIGHT
         self.setSize(w, h)
 
         # create stacks
@@ -126,36 +126,38 @@ class Boudoir(Game):
         l, s = Layout(self), self.s
         self.setSize(l.XM+5*l.XS, l.YM+4*l.YS)
 
-        x, y = l.XM+l.XS, l.YM
+        x, y = l.XM, l.YM+l.YS-l.TEXT_HEIGHT/2
-        for i in range(4):
-            s.foundations.append(SS_FoundationStack(x, y, self, suit=i, max_cards=13))
-            x += l.XS
-
-        x, y = l.XM, l.YS
         s.talon = WasteTalonStack(x, y, self, max_rounds=3)
         s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                              x + l.CW / 2, y - l.YM,
                                              anchor="s",
                                              font=self.app.getFont("canvas_default"))
         l.createText(s.talon, "s")
-        x += l.XS
+        y += l.YS+l.TEXT_HEIGHT
-        y += l.YM
+        s.waste = WasteStack(x, y, self)
+        l.createText(s.waste, "s")
+
+        x, y = l.XM+l.XS, l.YM
+        for i in range(4):
+            s.foundations.append(SS_FoundationStack(x, y, self, suit=i, max_cards=13))
+            x += l.XS
+
+        x = l.XM+l.XS
+        y += l.YS
         for i in range(4):
             s.rows.append(AbstractFoundationStack(x, y, self, suit=i,
                           max_cards=1, max_move=0, base_rank=QUEEN))
             x += l.XS
 
-        x, y = l.XM, 2*l.YM+2*l.YS
+        x = l.XM+l.XS
-        s.waste = WasteStack(x, y, self)
+        y += l.YS
-        l.createText(s.waste, "s")
-        x += l.XS
-        y -= l.YM
         for i in range(4):
             s.rows.append(AbstractFoundationStack(x, y, self, suit=i,
                           max_cards=1, max_move=0, base_rank=JACK))
             x += l.XS
 
-        x, y = l.XM+l.XS, l.YM+3*l.YS
+        x = l.XM+l.XS
+        y += l.YS
         for i in range(4):
             s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
                                  mod=13, max_cards=11, base_rank=9, dir=-1))
@@ -186,16 +188,16 @@ class CaptiveQueens(Game):
     def createGame(self):
 
         l, s = Layout(self), self.s
-        self.setSize(l.XM+5*l.XS, l.YM+3*l.YS)
+        self.setSize(l.XM+5*l.XS, max(l.YM+3*l.YS, l.YM+2*l.YS+3*l.TEXT_HEIGHT))
 
-        x, y = l.XM, 4*l.YM
+        x, y = l.XM, l.YM+l.TEXT_HEIGHT
         s.talon = WasteTalonStack(x, y, self, max_rounds=3)
         s.talon.texts.rounds = MfxCanvasText(self.canvas,
                                              x + l.CW / 2, y - l.YM,
                                              anchor="s",
                                              font=self.app.getFont("canvas_default"))
         l.createText(s.talon, "s")
-        y += 2*l.YM+l.YS
+        y += l.YS+l.TEXT_HEIGHT
         s.waste = WasteStack(x, y, self)
         l.createText(s.waste, "s")
 

pysollib/games/tournament.py

@@ -90,10 +90,10 @@ class Tournament(Game):
         l, s = Layout(self), self.s
 
         # set window
-        self.setSize(l.XM+10*l.XS, max(l.YM+l.YS+20*l.YOFFSET, 5*l.YM+5*l.YS))
+        self.setSize(l.XM+10*l.XS, max(l.YM+l.YS+20*l.YOFFSET, 2*l.YM+5*l.YS))
 
         # create stacks
-        x, y, = l.XM+l.XS, l.YM
+        x, y, = l.XM+2*l.XS, l.YM
         for i in range(4):
             s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
             x = x + l.XS
@@ -101,7 +101,7 @@ class Tournament(Game):
             s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
                                                     base_rank=KING, dir=-1))
             x = x + l.XS
-        x, y = l.XM+2*l.XS, l.YM+l.YS
+        x, y = l.XM+2*l.XS, 2*l.YM+l.YS
         for i in range(6):
             stack = BasicRowStack(x, y, self, max_move=1, max_accept=0)
             s.rows.append(stack)
@@ -109,23 +109,23 @@ class Tournament(Game):
                 stack.CARD_YOFFSET = 0
             x = x + l.XS
 
-        x, y = l.XM, 4*l.YM+l.YS
+        x, y = l.XM, 2*l.YM+l.YS
         for i in range(4):
             self.s.reserves.append(ReserveStack(x, y, self))
             y += l.YS
-        x, y = l.XM+9*l.XS, 4*l.YM+l.YS
+        x, y = l.XM+9*l.XS, 2*l.YM+l.YS
         for i in range(4):
             self.s.reserves.append(ReserveStack(x, y, self))
             y += l.YS
 
         s.talon = Tournament_Talon(l.XM, l.YM, self, max_rounds=3)
-        ##l.createText(s.talon, "ss")
+        l.createText(s.talon, "se")
-        tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
+        tx, ty, ta, tf = l.getTextAttr(s.talon, "ne")
         s.talon.texts.rounds = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
                                              font=self.app.getFont("canvas_default"))
 
-        # default
+        # define stack-groups
-        l.defaultAll()
+        l.defaultStackGroups()
 
     #
     # game overrides

pysollib/games/ultra/hexadeck.py

@@ -332,7 +332,7 @@ class BitsNBytes(Game):
         y = l.YM
         s.talon = WasteTalonStack(x, y, self, num_deal=2, max_rounds=2)
         l.createText(s.talon, "ss")
-        y = y + l.YS + l.YM * 2
+        y += l.YS + l.TEXT_HEIGHT
         s.waste = WasteStack(x, y, self)
         l.createText(s.waste, "ss")
 

pysollib/layout.py

@@ -88,12 +88,13 @@ class Layout:
         self.YS = self.CH + YM          # YSPACE
         self.XOFFSET = images.CARD_XOFFSET
         self.YOFFSET = images.CARD_YOFFSET
+        self.TEXT_HEIGHT = 30
         self.__dict__.update(kw)
-##         if self.game.preview > 1:
+        if self.game.preview > 1:
-##             if kw.has_key("XOFFSET"):
+            if kw.has_key("XOFFSET"):
-##                 self.XOFFSET =  self.XOFFSET / self.game.preview
+                self.XOFFSET =  self.XOFFSET / self.game.preview
-##             if kw.has_key("YOFFSET"):
+            if kw.has_key("YOFFSET"):
-##                 self.YOFFSET =  self.YOFFSET / self.game.preview
+                self.YOFFSET =  self.YOFFSET / self.game.preview
 
     def __createStack(self, x, y, suit=None):
         stack = _LayoutStack(x, y, suit)
@@ -370,6 +371,7 @@ class Layout:
         # set size so that at least 19 cards are fully playable
         h = YS + (playcards-1)*self.YOFFSET
         h = max(h, 3*YS)
+        if texts: h += self.TEXT_HEIGHT
 
         # top
         x, y = (w - (rows*XS - XM))/2, YM
@@ -406,7 +408,7 @@ class Layout:
     #  - bottom: rows
     #
 
-    def klondikeLayout(self, rows, waste, texts=1, playcards=16, center=1):
+    def klondikeLayout(self, rows, waste, texts=1, playcards=16, center=1, text_height=0):
         S = self.__createStack
         CW, CH = self.CW, self.CH
         XM, YM = self.XM, self.YM
@@ -424,12 +426,14 @@ class Layout:
         h = max(h, 2 * YS)
 
         # top
+        ##text_height = 0
         x, y = XM, YM
         self.s.talon = s = S(x, y)
         if texts:
             if waste or not center or maxrows - frows <= 1:
                 # place text below stack
                 s.setText(x + CW / 2, y + YS, anchor="n")
+                text_height = self.TEXT_HEIGHT
             else:
                 # place text right of stack
                 s.setText(x + XS, y, anchor="nw", format="%3d")
@@ -439,6 +443,7 @@ class Layout:
             if texts:
                 # place text below stack
                 s.setText(x + CW / 2, y + YS, anchor="n")
+                text_height = self.TEXT_HEIGHT
 
         for row in range(foundrows):
             x = XM + (maxrows - frows) * XS
@@ -454,7 +459,8 @@ class Layout:
         # bottom
         x = XM
         if rows < maxrows: x += (maxrows-rows) * XS/2
-        y += YM * (3 - foundrows)
+        ##y += YM * (3 - foundrows)
+        y += text_height
         self.setRegion(self.s.rows, (-999, y - YM / 2, 999999, 999999))
         for i in range(rows):
             self.s.rows.append(S(x, y))