def createGame(self):
l, s = Layout(self), self.s
h0 = l.YS+4*l.YOFFSET
self.setSize(l.XM+11*l.XS, l.YM+2*l.YS+2*h0)
self.base_rank = ANY_RANK
x, y = l.XM, l.YM
s.talon = GrandmammasPatience_Talon(x, y, self)
l.createText(s.talon, 'ne')
x, y = self.width-4*l.XS, l.YM
for i in range(4):
s.foundations.append(
SS_FoundationStack(
x, y, self, suit=i,
dir=-1, mod=13, max_move=0, base_rank=ANY_RANK))
x += l.XS
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, "sw")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(
self.canvas, tx, ty, anchor=ta, font=font)
x, y = self.width-4*l.XS, self.height-l.YS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
mod=13, max_move=0, base_rank=ANY_RANK))
x += l.XS
stack = s.foundations[4]
tx, ty, ta, tf = l.getTextAttr(stack, "sw")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(
self.canvas, tx, ty, anchor=ta, font=font)
y = l.YM+l.YS
for i in range(2):
x = l.XM
for j in range(11):
s.rows.append(GrandmammasPatience_RowStack(x, y, self,
max_accept=1, max_cards=2))
x += l.XS
y += h0
x, y = l.XM, self.height-l.YS
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
l.defaultStackGroups()
self.sg.dropstacks.append(s.talon)
def createGame(self):
l, s = Layout(self), self.s
h0 = l.YS+4*l.YOFFSET
self.setSize(l.XM+11*l.XS, l.YM+2*l.YS+2*h0)
self.base_rank = ANY_RANK
x, y = l.XM, l.YM
s.talon = GrandmammasPatience_Talon(x, y, self)
l.createText(s.talon, 'ne')
x, y = self.width-4*l.XS, l.YM
for i in range(4):
s.foundations.append(
SS_FoundationStack(
x, y, self, suit=i,
dir=-1, mod=13, max_move=0, base_rank=ANY_RANK))
x += l.XS
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, "sw")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(
self.canvas, tx, ty, anchor=ta, font=font)
x, y = self.width-4*l.XS, self.height-l.YS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
mod=13, max_move=0, base_rank=ANY_RANK))
x += l.XS
stack = s.foundations[4]
tx, ty, ta, tf = l.getTextAttr(stack, "sw")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(
self.canvas, tx, ty, anchor=ta, font=font)
y = l.YM+l.YS
for i in range(2):
x = l.XM
for j in range(11):
s.rows.append(GrandmammasPatience_RowStack(x, y, self,
max_accept=1, max_cards=2))
x += l.XS
y += h0
x, y = l.XM, self.height-l.YS
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
l.defaultStackGroups()
self.sg.dropstacks.append(s.talon)
def createGame(self):
# create layout
l, s = Layout(self, TEXT_HEIGHT=40), self.s
help, text_width = self._getHelpText()
text_width += 2*l.XM
# set window
# (piles up to 20 cards are playable in default window size)
w = l.XM+max(4*l.XS+text_width, 8*l.XS)
h = l.YM+2*l.YS+5*l.YOFFSET+l.TEXT_HEIGHT+l.YS
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
for i in range(4):
stack = self.Foundation_Class(x, y, self,
mod=13, dir=i+1, base_rank=i)
s.foundations.append(stack)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x = x + l.XS
self.texts.help = MfxCanvasText(self.canvas, x + l.XM, y + l.CH / 2, text=help,
anchor="w", font=self.app.getFont("canvas_fixed"))
x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT
for i in range(8):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
s.talon = InitialDealTalonStack(l.XM, self.height-l.YS, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+10*l.XS, l.YM+2*l.YS+12*l.YOFFSET)
# extra settings
self.base_card = None
# create stacks
x, y = l.XM+3*l.XS, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self,
suit=i, mod=13))
x = x + l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "ne")
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
for i in range(10):
s.rows.append(UD_AC_RowStack(x, y, self, mod=13))
x += l.XS
x, y = l.XM, l.YM
s.talon = InitialDealTalonStack(x, y, self)
# default
l.defaultAll()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 10 * l.XS, l.YM + 2 * l.YS + 12 * l.YOFFSET)
# extra settings
self.base_card = None
# create stacks
x, y = l.XM + 3 * l.XS, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
mod=13))
x = x + l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "ne")
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
for i in range(10):
s.rows.append(UD_AC_RowStack(x, y, self, mod=13))
x += l.XS
x, y = l.XM, l.YM
s.talon = InitialDealTalonStack(x, y, self)
# default
l.defaultAll()
def createGame(self, rows=8, reserves=4, playcards=15):
decks = self.gameinfo.decks
l, s = Layout(self), self.s
self.setSize(l.XM+rows*l.XS, l.YM+2*l.YS+playcards*l.YOFFSET)
x, y = l.XM, l.YM
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x = self.width - 2*l.XS
s.foundations.append(FourByFour_Foundation(x, y, self,
suit=ANY_SUIT, base_rank=ACE, max_cards=52*decks,
max_accept=1, max_move=0))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'ne')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = l.XM, l.YM+l.YS
for i in range(rows):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
x, y = l.XM, self.height-l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.defaultStackGroups()
def createGame(self):
playcards = 6
l, s = Layout(self), self.s
self.setSize(
l.XM+10*l.XS, l.YM+3*l.YS+2*playcards*l.YOFFSET+l.TEXT_HEIGHT)
x, y = l.XM, l.YM
s.talon = SlyFox_Talon(x, y, self)
s.waste = s.talon
l.createText(s.talon, 'ne')
tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
font = self.app.getFont("canvas_default")
self.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x += 2*l.XS
for i in range(4):
s.foundations.append(SlyFox_Foundation(x, y, self, suit=i))
s.foundations.append(SlyFox_Foundation(x+4*l.XS, y, self, suit=i,
base_rank=KING, dir=-1))
x += l.XS
y = l.YM+l.YS+l.TEXT_HEIGHT
for i in range(2):
x = l.XM
for j in range(10):
stack = SlyFox_RowStack(x, y, self, max_cards=UNLIMITED_CARDS)
s.rows.append(stack)
stack.CARD_YOFFSET = l.YOFFSET
x += l.XS
y += l.YS+playcards*l.YOFFSET
l.defaultStackGroups()
def createGame(self, rows=10):
l, s = Layout(self), self.s
# set size so that at least 2/3 of a card is visible with 15 cards
h = l.CH * 2 / 3 + (15 - 1) * l.YOFFSET
h = l.YS + max(h, 3 * l.YS)
self.setSize(l.XM + rows * l.XS, l.YM + h)
x, y = l.XM + (rows - 8) * l.XS, l.YM
for i in range(4):
s.foundations.append(Braid_Foundation(x, y, self, suit=i))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "se")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x += 2 * l.XS
stack = ReserveStack(x, y, self, max_cards=UNLIMITED_CARDS)
s.reserves.append(stack)
l.createText(stack, 'se')
x, y = l.XM, l.YM + l.YS
for i in range(rows):
s.rows.append(TheLittleCorporal_RowStack(x, y, self, mod=13))
x += l.XS
# talon
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
rows = 8
l, s = Layout(self), self.s
self.setSize(l.XM + rows * l.XS, l.YM + 2 * l.YS + 20 * l.YOFFSET)
x, y = l.XM, l.YM
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self))
x += l.XS
x, y = l.XM + (rows - 1) * l.XS // 2, self.height - l.YS
s.foundations.append(
Waterfall_Foundation(x, y, self, suit=ANY_SUIT, max_cards=104))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'se')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = self.width - l.XS, self.height - l.YS
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, 'sw')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+13*l.XS, l.YM+7*l.YS)
self.base_rank = ANY_RANK
x, y = l.XM+2.5*l.XS, l.YM
for i in range(8):
s.foundations.append(StepUp_Foundation(x, y, self,
suit=i%4, mod=13, base_rank=ANY_RANK))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[0], "sw")
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
for i in range(13):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x, y = l.XM+2*l.XS, l.YM+2*l.YS
for i in range(9):
s.rows.append(StepUp_RowStack(x, y, self, max_move=1, mod=13))
x += l.XS
x, y = l.XM, l.YM+2.5*l.YS
s.talon = StepUp_Talon(x, y, self, max_rounds=1)
l.createText(s.talon, 'se')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'se')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+9*l.XS, l.YM+4*l.YS)
x, y = l.XM, l.YM
s.talon = SlyFox_Talon(x, y, self)
s.waste = s.talon
l.createText(s.talon, 'ne')
tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
font = self.app.getFont("canvas_default")
self.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
y = l.YM
for i in range(4):
x = l.XM+1.5*l.XS
for j in range(5):
stack = SlyFox_RowStack(x, y, self, max_cards=UNLIMITED_CARDS)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x += l.XS
y += l.YS
x, y = self.width-2*l.XS, l.YM
for i in range(4):
s.foundations.append(SlyFox_Foundation(x, y, self, suit=i))
s.foundations.append(SlyFox_Foundation(x+l.XS, y, self, suit=i,
base_rank=KING, dir=-1))
y += l.YS
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self, TEXT_HEIGHT=40), self.s
help, text_width = self._getHelpText()
text_width += 2*l.XM
# set window
# (piles up to 20 cards are playable in default window size)
w = l.XM+max(4*l.XS+text_width, 8*l.XS)
h = l.YM+2*l.YS+5*l.YOFFSET+l.TEXT_HEIGHT+l.YS
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
for i in range(4):
stack = self.Foundation_Class(x, y, self,
mod=13, dir=i+1, base_rank=i)
s.foundations.append(stack)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x = x + l.XS
self.texts.help = MfxCanvasText(
self.canvas, x + l.XM, y + l.CH // 2, text=help,
anchor="w", font=self.app.getFont("canvas_fixed"))
x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT
for i in range(8):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
s.talon = InitialDealTalonStack(l.XM, self.height-l.YS, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=10):
l, s = Layout(self), self.s
# set size so that at least 2/3 of a card is visible with 15 cards
h = l.CH*2/3 + (15-1)*l.YOFFSET
h = l.YS + max(h, 3*l.YS)
self.setSize(l.XM+rows*l.XS, l.YM + h)
x, y = l.XM+(rows-8)*l.XS, l.YM
for i in range(4):
s.foundations.append(Braid_Foundation(x, y, self, suit=i))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "se")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font)
x += 2*l.XS
stack = ReserveStack(x, y, self, max_cards=UNLIMITED_CARDS)
s.reserves.append(stack)
l.createText(stack, 'se')
x, y = l.XM, l.YM+l.YS
for i in range(rows):
s.rows.append(TheLittleCorporal_RowStack(x, y, self, mod=13))
x += l.XS
# talon
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
playcards = 6
l, s = Layout(self), self.s
self.setSize(
l.XM+10*l.XS, l.YM+3*l.YS+2*playcards*l.YOFFSET+l.TEXT_HEIGHT)
x, y = l.XM, l.YM
s.talon = SlyFox_Talon(x, y, self)
s.waste = s.talon
l.createText(s.talon, 'ne')
tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
font = self.app.getFont("canvas_default")
self.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x += 2*l.XS
for i in range(4):
s.foundations.append(SlyFox_Foundation(x, y, self, suit=i))
s.foundations.append(SlyFox_Foundation(x+4*l.XS, y, self, suit=i,
base_rank=KING, dir=-1))
x += l.XS
y = l.YM+l.YS+l.TEXT_HEIGHT
for i in range(2):
x = l.XM
for j in range(10):
stack = SlyFox_RowStack(x, y, self, max_cards=UNLIMITED_CARDS)
s.rows.append(stack)
stack.CARD_YOFFSET = l.YOFFSET
x += l.XS
y += l.YS+playcards*l.YOFFSET
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 9.5 * l.XS, l.YM + 3 * l.YS)
x, y = l.XM + 1.5 * l.XS, l.YM
for i in range(8):
stack = BetsyRoss_Foundation(x,
y,
self,
base_rank=i,
mod=13,
dir=i + 1,
max_move=0)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
s.foundations.append(stack)
x = x + l.XS
x, y = l.XM + 1.5 * l.XS, l.YM + 2 * l.YS
for i in range(8):
stack = SeniorWrangler_RowStack(x, y, self, max_accept=0)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x += l.XS
x, y = l.XM, l.YM + l.YS
s.talon = SeniorWrangler_Talon(x, y, self, max_rounds=9)
l.createRoundText(s.talon, 'nn')
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=8, reserves=4, playcards=15):
decks = self.gameinfo.decks
l, s = Layout(self), self.s
self.setSize(l.XM+rows*l.XS, l.YM+2*l.YS+playcards*l.YOFFSET)
x, y = l.XM, l.YM
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x = self.width - 2*l.XS
s.foundations.append(FourByFour_Foundation(x, y, self,
suit=ANY_SUIT, base_rank=ACE, max_cards=52*decks,
max_accept=1, max_move=0))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'ne')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = l.XM, l.YM+l.YS
for i in range(rows):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
x, y = l.XM, self.height-l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+13*l.XS, l.YM+7*l.YS)
self.base_rank = ANY_RANK
x, y = l.XM+2.5*l.XS, l.YM
for i in range(8):
s.foundations.append(StepUp_Foundation(x, y, self,
suit=i % 4, mod=13, base_rank=ANY_RANK))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[0], "sw")
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
for i in range(13):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x, y = l.XM+2*l.XS, l.YM+2*l.YS
for i in range(9):
s.rows.append(StepUp_RowStack(x, y, self, max_move=1, mod=13))
x += l.XS
x, y = l.XM, l.YM+2.5*l.YS
s.talon = StepUp_Talon(x, y, self, max_rounds=1)
l.createText(s.talon, 'se')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'se')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+7*l.XS, l.YM+2*l.YS+20*l.YOFFSET)
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 's')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 's')
x += 3.5*l.XS
s.foundations.append(FourByFour_Foundation(x, y, self,
suit=ANY_SUIT, base_rank=ANY_RANK, max_cards=52,
max_accept=1, max_move=0, mod=13))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'ne')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = l.XM+3*l.XS, l.YM+l.YS
for i in range(4):
stack = UD_RK_RowStack(x, y, self, mod=13)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
x += l.XS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+9*l.XS, l.YM+4*l.YS)
x, y = l.XM, l.YM
s.talon = SlyFox_Talon(x, y, self)
s.waste = s.talon
l.createText(s.talon, 'ne')
tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
font = self.app.getFont("canvas_default")
self.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
y = l.YM
for i in range(4):
x = l.XM+1.5*l.XS
for j in range(5):
stack = SlyFox_RowStack(x, y, self, max_cards=UNLIMITED_CARDS)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x += l.XS
y += l.YS
x, y = self.width-2*l.XS, l.YM
for i in range(4):
s.foundations.append(SlyFox_Foundation(x, y, self, suit=i))
s.foundations.append(SlyFox_Foundation(x+l.XS, y, self, suit=i,
base_rank=KING, dir=-1))
y += l.YS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+7*l.XS, l.YM+2*l.YS+20*l.YOFFSET)
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 's')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 's')
x += 3.5*l.XS
s.foundations.append(FourByFour_Foundation(x, y, self,
suit=ANY_SUIT, base_rank=ANY_RANK, max_cards=52,
max_accept=1, max_move=0, mod=13))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'ne')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = l.XM+3*l.XS, l.YM+l.YS
for i in range(4):
stack = UD_RK_RowStack(x, y, self, mod=13)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
x += l.XS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+9.5*l.XS, l.YM+3*l.YS)
x, y = l.XM+1.5*l.XS, l.YM
for i in range(8):
stack = BetsyRoss_Foundation(x, y, self, base_rank=i,
mod=13, dir=i+1, max_move=0)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
s.foundations.append(stack)
x = x + l.XS
x, y = l.XM+1.5*l.XS, l.YM+2*l.YS
for i in range(8):
stack = SeniorWrangler_RowStack(x, y, self, max_accept=0)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x += l.XS
x, y = l.XM, l.YM+l.YS
s.talon = SeniorWrangler_Talon(x, y, self, max_rounds=9)
l.createRoundText(s.talon, 'nn')
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
help, text_width = self._getHelpText()
text_width += 2 * l.XM
# set window
self.setSize(5.5 * l.XS + l.XM + text_width,
l.YM + 3 * l.YS + l.TEXT_HEIGHT)
# create stacks
x0 = l.XM + l.XS * 3 / 2
x, y = x0, l.YM
for i in range(4):
stack = BetsyRoss_Foundation(x,
y,
self,
base_rank=i,
max_cards=1,
max_move=0,
max_accept=0)
s.foundations.append(stack)
x += l.XS
x = x0
y = l.YM + l.YS
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)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
s.foundations.append(stack)
x += l.XS
self.texts.help = MfxCanvasText(self.canvas,
x + l.XM,
y + l.CH / 2,
text=help,
anchor="w",
font=self.app.getFont("canvas_fixed"))
x = l.XM
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, "n")
l.createRoundText(s.talon, 'nnn')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
self.base_card = None
# create layout
l, s = Layout(self), self.s
# set window
# (set size so that at least 3 cards are fully playable)
w = max(2 * l.XS, l.XS + 3 * l.XOFFSET)
w = min(3 * l.XS, w)
w = (w + 1) & ~1
self.setSize(l.XM + 6 * w, l.YM + 4 * l.YS + l.TEXT_HEIGHT)
dx = (self.width - 4 * l.XS) // (4 + 1)
x, y = l.XM + dx, l.YM
dx += l.XS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
mod=13))
x += dx
tx, ty, ta, tf = l.getTextAttr(s.foundations[0], "s")
self.texts.info = \
MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=self.app.getFont("canvas_default"))
y += l.TEXT_HEIGHT
for i in range(3):
x, y = l.XM, y + l.YS
for j in range(5):
stack = UD_SS_RowStack(x,
y,
self,
max_move=1,
max_accept=1,
base_rank=NO_RANK,
mod=13,
max_cards=3)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
x += w
stack = UD_SS_RowStack(x,
y,
self,
max_move=1,
max_accept=1,
base_rank=ANY_RANK,
mod=13,
max_cards=3)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
x, y = self.width - l.XS, self.height - l.YS
s.talon = self.Talon_Class(x, y, self)
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self):
layout, s = Layout(self), self.s
self.setSize(
layout.XM + 9 * layout.XS, layout.YM + 3 * layout.YS +
7 * layout.YOFFSET + 2 * layout.TEXT_HEIGHT)
x, y = layout.XM + 4 * layout.XS, layout.YM
stack = DevilsSolitaire_Foundation(x,
y,
self,
suit=ANY_SUIT,
base_rank=ANY_RANK,
mod=13)
tx, ty, ta, tf = layout.getTextAttr(stack, 'nw')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
s.foundations.append(stack)
x, y = self.width - layout.XS, layout.YM
stack = AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_move=0,
max_cards=104,
max_accept=0,
base_rank=ANY_RANK)
layout.createText(stack, 'nw')
s.foundations.append(stack)
x, y = layout.XM, layout.YM + layout.YS
for i in range(4):
s.rows.append(Vague_RowStack(x, y, self))
x += layout.XS
x += layout.XS
for i in range(4):
s.rows.append(Vague_RowStack(x, y, self))
x += layout.XS
x, y = layout.XM + 4 * layout.XS, layout.YM + layout.YS
stack = OpenStack(x, y, self)
stack.CARD_YOFFSET = layout.YOFFSET
s.reserves.append(stack)
x, y = layout.XM + 4.5 * layout.XS, self.height - layout.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
layout.createText(s.talon, 'n')
layout.createRoundText(s.talon, 'nnn')
x -= layout.XS
s.waste = DevilsSolitaire_WasteStack(x, y, self)
layout.createText(s.waste, 'n')
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 11 * l.XS, l.YM + 3 * l.YS + 16 * l.YOFFSET)
# create stacks
#
x, y = l.XM, self.height - l.YS
s.talon = DoubleFives_Talon(x, y, self, max_rounds=2, num_deal=1)
l.createText(s.talon, "n")
l.createRoundText(self.s.talon, 'nnn')
x += l.XS
for i in range(5):
s.reserves.append(DoubleFives_WasteStack(x, y, self))
x += l.XS
l.createText(s.reserves[0], 'n')
#
x = self.width - l.XS
s.addattr(stock=None) # register extra stack variable
s.stock = DoubleFives_Stock(x, y, self)
l.createText(s.stock, "n")
#
x, y = l.XM, l.YM
s.reserves.append(Glenwood_ReserveStack(x, y, self))
x += l.XS
s.reserves.append(Glenwood_ReserveStack(x, y, self))
#
x += 2 * l.XS
for i in range(8):
s.foundations.append(
Glenwood_Foundation(x,
y,
self,
suit=i / 2,
mod=13,
base_rank=ANY_RANK,
max_move=0))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(None, "ss")
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)
x, y = l.XM + l.XS / 2, l.YM + l.YS + l.TEXT_HEIGHT
for i in range(10):
s.rows.append(DoubleFives_RowStack(x, y, self, mod=13, max_move=1))
x += l.XS
# define stack-groups
l.defaultStackGroups()
def createGame(self, playcards=13, reserves=0, texts=False):
# create layout
l, s = Layout(self), self.s
# set window
# (set size so that at least 13 cards are fully playable)
w = max(3 * l.XS, l.XS + (playcards - 1) * l.XOFFSET)
x0 = l.XM
x1 = x0 + w + 2 * l.XM
x2 = x1 + l.XS + 2 * l.XM
x3 = x2 + w + l.XM
h = l.YM + (4 + int(reserves != 0)) * l.YS + int(texts) * l.TEXT_HEIGHT
self.setSize(x3, h)
# create stacks
y = l.YM
if reserves:
x = x1 - int(l.XS * (reserves - 1) / 2)
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
y += l.YS
x = x1
for i in range(4):
s.foundations.append(
self.Foundation_Class(x, y, self, suit=i, max_move=0))
y += l.YS
if texts:
tx, ty, ta, tf = l.getTextAttr(None, "ss")
tx, ty = x + tx, y - l.YS + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
for x in (x0, x2):
y = l.YM + l.YS * int(reserves != 0)
for i in range(4):
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
if reserves:
l.setRegion(
s.rows[:4],
(-999, l.YM + l.YS - l.CH // 2, x1 - l.CW // 2, 999999))
else:
l.setRegion(s.rows[:4], (-999, -999, x1 - l.CW // 2, 999999))
# default
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self, TEXT_HEIGHT=40), self.s
help, text_width = self._getHelpText()
text_width += 2 * l.XM
# set window
w = l.XM + 5.5 * l.XS + text_width
h = max(2 * l.YS, 20 * l.YOFFSET)
self.setSize(w, l.YM + l.YS + l.TEXT_HEIGHT + h)
# create stacks
x0 = l.XM + l.XS * 3 / 2
x, y = x0, l.YM
for i in range(4):
stack = self.Foundation_Class(x,
y,
self,
mod=13,
dir=i + 1,
base_rank=i)
s.foundations.append(stack)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x = x + l.XS
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 + l.TEXT_HEIGHT
for i in range(4):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
self.setRegion(s.rows, (-999, y - l.CH / 2, 999999, 999999))
x = l.XM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "n")
y = y + l.YS
s.waste = WasteStack(x, y, self, max_cards=1)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
lay, s = Layout(self), self.s
# set window
playcards = 8
w0 = lay.XS + playcards * lay.XOFFSET
w = lay.XM + lay.XS // 2 + max(10 * lay.XS, lay.XS + 4 * w0)
h = lay.YM + 5 * lay.YS + lay.TEXT_HEIGHT
self.setSize(w, h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
lay.createText(s.talon, 's')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, 's')
x = self.width - 8 * lay.XS
for i in range(8):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i % 4, mod=13))
x += lay.XS
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x - lay.XS + tx, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = lay.XM, lay.YM + lay.YS + lay.TEXT_HEIGHT
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
y += lay.YS
y = lay.YM + lay.YS + lay.TEXT_HEIGHT
for i in range(4):
x = lay.XM + lay.XS + lay.XS // 2
for j in range(4):
stack = RK_RowStack(x, y, self, max_move=1, mod=13)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
x += w0
y += lay.YS
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 7 * 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, "s")
l.createRoundText(s.talon, 'ne', dx=l.XS)
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
x += 2 * l.XS
for i in range(4):
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, "ss")
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 = l.XM + (i + 3) * l.XS
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 = 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
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=3):
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 4 cards are playable in default window size)
h = max((2 * l.YS) + l.TEXT_HEIGHT, (4 * l.YOFFSET))
self.setSize(l.XM + (1.5 + rows) * l.XS + l.XM, l.YM + h)
# create stacks
x0 = l.XM + (l.XS * 1.5)
x = x0
y = l.YM
font = self.app.getFont("canvas_default")
for i in range(rows):
stack = BasicRowStack(x,
y,
self,
max_cards=5,
max_accept=0,
max_move=1)
if self.preview <= 1:
tx, ty, ta, tf = l.getTextAttr(stack, anchor="n")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
s.rows.append(stack)
x = x + l.XS
self.setRegion(s.rows, (x0 - l.XS // 2, y - l.CH // 2, 999999, 999999))
x, y = l.XM, l.YM
s.talon = Knockout_Talon(x, y, self, max_rounds=3)
l.createText(s.talon, 'ne')
l.createRoundText(s.talon, 's')
y = y + l.YS + l.TEXT_HEIGHT
s.foundations.append(
Knockout_Foundation(x,
y,
self,
max_move=0,
base_rank=ANY_RANK,
suit=self.FOUNDATION_SUIT))
l.createText(s.foundations[0], 'se')
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self, playcards=13, reserves=0, texts=False):
# create layout
l, s = Layout(self), self.s
# set window
# (set size so that at least 13 cards are fully playable)
w = max(3*l.XS, l.XS+(playcards-1)*l.XOFFSET)
x0 = l.XM
x1 = x0 + w + 2*l.XM
x2 = x1 + l.XS + 2*l.XM
x3 = x2 + w + l.XM
h = l.YM + (4+int(reserves != 0))*l.YS + int(texts)*l.TEXT_HEIGHT
self.setSize(x3, h)
# create stacks
y = l.YM
if reserves:
x = x1 - int(l.XS*(reserves-1)/2)
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
y += l.YS
x = x1
for i in range(4):
s.foundations.append(
self.Foundation_Class(x, y, self, suit=i, max_move=0))
y += l.YS
if texts:
tx, ty, ta, tf = l.getTextAttr(None, "ss")
tx, ty = x+tx, y-l.YS+ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
for x in (x0, x2):
y = l.YM+l.YS*int(reserves != 0)
for i in range(4):
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
if reserves:
l.setRegion(
s.rows[:4], (-999, l.YM+l.YS-l.CH//2, x1-l.CW//2, 999999))
else:
l.setRegion(s.rows[:4], (-999, -999, x1-l.CW//2, 999999))
# default
l.defaultAll()
def createGame(self):
# create layout
lay, s = Layout(self), self.s
# set window
playcards = 8
w0 = lay.XS+playcards*lay.XOFFSET
w = lay.XM+lay.XS//2+max(10*lay.XS, lay.XS+4*w0)
h = lay.YM+5*lay.YS+lay.TEXT_HEIGHT
self.setSize(w, h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
lay.createText(s.talon, 's')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, 's')
x = self.width - 8*lay.XS
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self,
suit=i % 4, mod=13))
x += lay.XS
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x-lay.XS+tx, y+ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = lay.XM, lay.YM+lay.YS+lay.TEXT_HEIGHT
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
y += lay.YS
y = lay.YM+lay.YS+lay.TEXT_HEIGHT
for i in range(4):
x = lay.XM+lay.XS+lay.XS//2
for j in range(4):
stack = RK_RowStack(x, y, self, max_move=1, mod=13)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
x += w0
y += lay.YS
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+11*l.XS, l.YM+3*l.YS+16*l.YOFFSET)
# create stacks
#
x, y = l.XM, self.height-l.YS
s.talon = DoubleFives_Talon(x, y, self, max_rounds=2, num_deal=1)
l.createText(s.talon, "n")
l.createRoundText(self.s.talon, 'nnn')
x += l.XS
for i in range(5):
s.reserves.append(DoubleFives_WasteStack(x, y, self))
x += l.XS
l.createText(s.reserves[0], 'n')
#
x = self.width-l.XS
s.addattr(stock=None) # register extra stack variable
s.stock = DoubleFives_Stock(x, y, self)
l.createText(s.stock, "n")
#
x, y = l.XM, l.YM
s.reserves.append(Glenwood_ReserveStack(x, y, self))
x += l.XS
s.reserves.append(Glenwood_ReserveStack(x, y, self))
#
x += 2*l.XS
for i in range(8):
s.foundations.append(Glenwood_Foundation(x, y, self, suit=i//2,
mod=13, base_rank=ANY_RANK, max_move=0))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(None, "ss")
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)
x, y = l.XM+l.XS//2, l.YM+l.YS+l.TEXT_HEIGHT
for i in range(10):
s.rows.append(DoubleFives_RowStack(x, y, self, mod=13, max_move=1))
x += l.XS
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=8, text=False):
# create layout
l, s = Layout(self), self.s
# set window
max_rows = max(rows, self.gameinfo.decks * 4)
w, h = 2 * l.XM + l.XS + max_rows * l.XS + l.XS / 2, l.YM + l.TEXT_HEIGHT + 5 * l.YS
self.setSize(w, h)
# create stacks
x, y, = w - l.XS * self.gameinfo.decks * 4, l.YM
for j in range(self.gameinfo.decks):
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, suit=i))
x += l.XS
if text:
x, y = w - l.XS, l.YM
tx, ty, ta, tf = l.getTextAttr(None, "ss")
tx, ty = x + tx, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = w - rows * l.XS, l.YM + l.YS
if text:
y += l.TEXT_HEIGHT
for i in range(rows):
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.rows.append(stack)
x += l.XS
x, y, = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, "s")
y += l.TEXT_HEIGHT
for i in range(3):
y += l.YS
stack = self.ReserveStack_Class(x, y, self)
s.reserves.append(stack)
l.createText(stack, "se")
# define stack-groups
l.defaultStackGroups()
def createGame(self, cells=1, reserves=2, texts=True):
# create layout
l, s = Layout(self), self.s
# set window
# set size so that at least 2/3 of a card is visible with 15 cards
h = l.CH * 2 / 3 + (15 - 1) * l.YOFFSET
h = l.YS + max(h, 3 * l.YS)
max_rows = 8 + max(cells, reserves)
self.setSize(l.XM + 2 * l.XM + max_rows * l.XS, l.YM + h)
x1 = l.XM + 8 * l.XS + 2 * l.XM
# create stacks
y = l.YM + l.YS
for j in range(8):
x = l.XM + j * l.XS
s.rows.append(self.RowStack_Class(x, y, self))
for j in range(reserves):
x = x1 + j * l.XS
s.rows.append(self.ReserveStack_Class(x, y, self))
self.setRegion(s.rows, (-999, y - l.CH / 2, 999999, 999999))
y = l.YM
x = x1 + (max(cells, reserves) - cells) * l.XS / 2
for i in range(cells):
s.reserves.append(self.FreeCell_Class(x, y, self))
x += l.XS
# foundations
x = l.XM + 2 * l.XS
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, i))
x = x + l.XS
if texts:
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "se")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
# talon
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=3, cols=3, reserves=3, texts=False):
l, s = Layout(self), self.s
self.setSize(l.XM + (cols + 2) * l.XS, l.YM + (rows + 1.5) * l.YS)
x, y = self.width - l.XS, l.YM
s.talon = TalonStack(x, y, self)
l.createText(s.talon, 's')
x, y = self.width - l.XS, self.height - l.YS
s.foundations.append(
AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_accept=0,
max_move=0,
max_cards=52))
l.createText(s.foundations[0], 'n')
y = l.YM
for i in range(rows):
x = l.XM
for j in range(cols):
s.rows.append(self.RowStack_Class(x, y, self, max_accept=1))
x += l.XS
y += l.YS
x, y = l.XM, self.height - l.YS
for i in range(reserves):
stack = self.Reserve_Class(x, y, self)
s.reserves.append(stack)
stack.CARD_XOFFSET = l.XOFFSET # for fifteens
x += l.XS
if texts:
stack = s.reserves[0]
tx, ty, ta, tf = l.getTextAttr(stack, "n")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+9*l.XS, l.YM+3*l.YS+7*l.YOFFSET+2*l.TEXT_HEIGHT)
x, y = l.XM+4*l.XS, l.YM
stack = DevilsSolitaire_Foundation(
x, y, self, suit=ANY_SUIT, base_rank=ANY_RANK, mod=13)
tx, ty, ta, tf = l.getTextAttr(stack, 'nw')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
s.foundations.append(stack)
x, y = self.width-l.XS, l.YM
stack = AbstractFoundationStack(
x, y, self,
suit=ANY_SUIT, max_move=0, max_cards=104,
max_accept=0, base_rank=ANY_RANK)
l.createText(stack, 'nw')
s.foundations.append(stack)
x, y = l.XM, l.YM+l.YS
for i in range(4):
s.rows.append(Vague_RowStack(x, y, self))
x += l.XS
x += l.XS
for i in range(4):
s.rows.append(Vague_RowStack(x, y, self))
x += l.XS
x, y = l.XM+4*l.XS, l.YM+l.YS
stack = OpenStack(x, y, self)
stack.CARD_YOFFSET = l.YOFFSET
s.reserves.append(stack)
x, y = l.XM+4.5*l.XS, self.height-l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, 'n')
l.createRoundText(s.talon, 'nnn')
x -= l.XS
s.waste = DevilsSolitaire_WasteStack(x, y, self)
l.createText(s.waste, 'n')
l.defaultStackGroups()
def createGame(self):
# Canfield.createGame(self, rows=8, max_rounds=3, num_deal=1)
# create layout
lay, s = Layout(self), self.s
# set window
self.setSize(lay.XM + 9 * lay.XS + lay.XM, lay.YM + 4 * lay.YS)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=3, num_deal=1)
lay.createText(s.talon, "s")
lay.createRoundText(s.talon, 'ne', dx=lay.XS)
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, "s")
for i in range(4):
x = lay.XM + (i + 3) * lay.XS
s.foundations.append(
self.Foundation_Class(x, y, self, i, mod=13, max_move=0))
tx, ty, ta, tf = lay.getTextAttr(None, "se")
tx, ty = x + tx + lay.XM, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
ry = lay.YM + 2 * lay.YS
for i in range(8):
x = lay.XM + (i + (i >= 4)) * lay.XS
y = ry - (0.2, 0.4, 0.6, 0.4, 0.4, 0.6, 0.4, 0.2)[i] * lay.CH
s.rows.append(self.RowStack_Class(x, y, self))
x, y = lay.XM + 4 * lay.XS, ry
s.reserves.append(self.ReserveStack_Class(x, y, self))
# s.reserves[0].CARD_YOFFSET = 0
lay.createText(s.reserves[0], "s")
# define stack-groups
lay.defaultStackGroups()
def createGame(self, rows=8, text=False):
# create layout
l, s = Layout(self), self.s
# set window
max_rows = max(rows, self.gameinfo.decks*4)
w, h = 2*l.XM+l.XS+max_rows*l.XS+l.XS//2, l.YM+l.TEXT_HEIGHT+5*l.YS
self.setSize(w, h)
# create stacks
x, y, = w-l.XS*self.gameinfo.decks*4, l.YM
for j in range(self.gameinfo.decks):
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, suit=i))
x += l.XS
if text:
x, y = w-l.XS, l.YM
tx, ty, ta, tf = l.getTextAttr(None, "ss")
tx, ty = x+tx, y+ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = w-rows*l.XS, l.YM+l.YS
if text:
y += l.TEXT_HEIGHT
for i in range(rows):
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.rows.append(stack)
x += l.XS
x, y, = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, "s")
y += l.TEXT_HEIGHT
for i in range(3):
y += l.YS
stack = self.ReserveStack_Class(x, y, self)
s.reserves.append(stack)
l.createText(stack, "se")
# define stack-groups
l.defaultStackGroups()
def createGame(self, cells=1, reserves=2, texts=True):
# create layout
l, s = Layout(self), self.s
# set window
# set size so that at least 2/3 of a card is visible with 15 cards
h = l.CH*2/3 + (15-1)*l.YOFFSET
h = l.YS + max(h, 3*l.YS)
max_rows = 8+max(cells, reserves)
self.setSize(l.XM + 2*l.XM + max_rows*l.XS, l.YM + h)
x1 = l.XM + 8*l.XS + 2*l.XM
# create stacks
y = l.YM + l.YS
for j in range(8):
x = l.XM + j*l.XS
s.rows.append(self.RowStack_Class(x, y, self))
for j in range(reserves):
x = x1 + j*l.XS
s.rows.append(self.ReserveStack_Class(x, y, self))
self.setRegion(s.rows, (-999, y - l.CH/2, 999999, 999999))
y = l.YM
x = x1+(max(cells, reserves)-cells)*l.XS/2
for i in range(cells):
s.reserves.append(self.FreeCell_Class(x, y, self))
x += l.XS
# foundations
x = l.XM + 2*l.XS
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, i))
x = x + l.XS
if texts:
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "se")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=font)
# talon
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
help, text_width = self._getHelpText()
text_width += 2*l.XM
# set window
self.setSize(5.5*l.XS+l.XM+text_width, l.YM+3*l.YS+l.TEXT_HEIGHT)
# create stacks
x0 = l.XM + l.XS * 3 / 2
x, y = x0, l.YM
for i in range(4):
stack = BetsyRoss_Foundation(x, y, self, base_rank=i,
max_cards=1, max_move=0, max_accept=0)
s.foundations.append(stack)
x += l.XS
x = x0
y = l.YM + l.YS
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)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
s.foundations.append(stack)
x += l.XS
self.texts.help = MfxCanvasText(self.canvas, x + l.XM, y + l.CH / 2,
text=help, anchor="w",
font=self.app.getFont("canvas_fixed"))
x = l.XM
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, "n")
l.createRoundText(s.talon, 'nnn')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
rows = 8
l, s = Layout(self), self.s
self.setSize(l.XM + rows * l.XS, l.YM + 2 * l.YS + 20 * l.YOFFSET)
x, y = l.XM, l.YM
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self))
x += l.XS
x, y = l.XM + (rows - 1) * l.XS / 2, self.height - l.YS
s.foundations.append(Waterfall_Foundation(x, y, self, suit=ANY_SUIT, max_cards=104))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, "se")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font)
x, y = self.width - l.XS, self.height - l.YS
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, "sw")
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self, TEXT_HEIGHT=40), self.s
help, text_width = self._getHelpText()
text_width += 2*l.XM
# set window
w = l.XM+5.5*l.XS+text_width
h = max(2*l.YS, 20*l.YOFFSET)
self.setSize(w, l.YM + l.YS + l.TEXT_HEIGHT + h)
# create stacks
x0 = l.XM + l.XS * 3 // 2
x, y = x0, l.YM
for i in range(4):
stack = self.Foundation_Class(x, y, self,
mod=13, dir=i+1, base_rank=i)
s.foundations.append(stack)
tx, ty, ta, tf = l.getTextAttr(stack, "s")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x = x + l.XS
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 + l.TEXT_HEIGHT
for i in range(4):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
self.setRegion(s.rows, (-999, y-l.CH//2, 999999, 999999))
x = l.XM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "n")
y = y + l.YS
s.waste = WasteStack(x, y, self, max_cards=1)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# Canfield.createGame(self, rows=8, max_rounds=3, num_deal=1)
# create layout
lay, s = Layout(self), self.s
# set window
self.setSize(lay.XM + 9*lay.XS + lay.XM, lay.YM + 4*lay.YS)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=3, num_deal=1)
lay.createText(s.talon, "s")
lay.createRoundText(s.talon, 'ne', dx=lay.XS)
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, "s")
for i in range(4):
x = lay.XM + (i+3)*lay.XS
s.foundations.append(
self.Foundation_Class(x, y, self, i, mod=13, max_move=0))
tx, ty, ta, tf = lay.getTextAttr(None, "se")
tx, ty = x + tx + lay.XM, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(
self.canvas, tx, ty, anchor=ta, font=font)
ry = lay.YM + 2*lay.YS
for i in range(8):
x = lay.XM + (i + (i >= 4))*lay.XS
y = ry - (0.2, 0.4, 0.6, 0.4, 0.4, 0.6, 0.4, 0.2)[i]*lay.CH
s.rows.append(self.RowStack_Class(x, y, self))
x, y = lay.XM + 4*lay.XS, ry
s.reserves.append(self.ReserveStack_Class(x, y, self))
# s.reserves[0].CARD_YOFFSET = 0
lay.createText(s.reserves[0], "s")
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 7*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, "s")
l.createRoundText(s.talon, 'ne', dx=l.XS)
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
x += 2*l.XS
for i in range(4):
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, "ss")
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 = l.XM + (i+3)*l.XS
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 = 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
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=7):
self.used = False
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 4 cards are playable in default window size)
h = max(2 * l.YS, (4 * l.YOFFSET) + l.TEXT_HEIGHT)
self.setSize(l.XM + (1.5 + rows) * l.XS + l.XM, l.YM + h)
# create stacks
x0 = l.XM + (l.XS * 1.5)
x = x0
y = l.YM + l.TEXT_HEIGHT
font = self.app.getFont("canvas_default")
for i in range(rows):
stack = Ladybug_RowStack(x, y, self, max_cards=4,
max_accept=1, max_move=0)
if self.preview <= 1:
tx, ty, ta, tf = l.getTextAttr(stack, anchor="n")
stack.texts.misc = MfxCanvasText(self.canvas,
tx, ty,
anchor=ta,
font=font)
s.rows.append(stack)
x = x + l.XS
self.setRegion(s.rows, (x0-l.XS//2, y-l.CH//2, 999999, 999999))
x, y = l.XM, l.YM
s.talon = Ladybug_Talon(x, y, self, max_rounds=-1, num_deal=3)
l.createText(s.talon, 'ne')
y = y + l.YS
s.waste = Ladybug_Waste(x, y, self)
l.createText(s.waste, 'ne')
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self, rows=3, cols=3, reserves=3, texts=False):
l, s = Layout(self), self.s
self.setSize(l.XM+(cols+2)*l.XS, l.YM+(rows+1.5)*l.YS)
x, y = self.width-l.XS, l.YM
s.talon = TalonStack(x, y, self)
l.createText(s.talon, 's')
x, y = self.width-l.XS, self.height-l.YS
s.foundations.append(AbstractFoundationStack(x, y, self,
suit=ANY_SUIT, max_accept=0,
max_move=0, max_cards=52))
l.createText(s.foundations[0], 'n')
y = l.YM
for i in range(rows):
x = l.XM
for j in range(cols):
s.rows.append(self.RowStack_Class(x, y, self, max_accept=1))
x += l.XS
y += l.YS
x, y = l.XM, self.height-l.YS
for i in range(reserves):
stack = self.Reserve_Class(x, y, self)
s.reserves.append(stack)
stack.CARD_XOFFSET = l.XOFFSET # for fifteens
x += l.XS
if texts:
stack = s.reserves[0]
tx, ty, ta, tf = l.getTextAttr(stack, "n")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
l.defaultStackGroups()
def createGame(self,
rows=4,
max_rounds=-1,
num_deal=3,
text=True,
round_text=False):
# create layout
lay, s = Layout(self), self.s
decks = self.gameinfo.decks
# set window
if self.INITIAL_RESERVE_FACEUP == 1:
yoffset = lay.YOFFSET # min(lay.YOFFSET, 14)
else:
yoffset = 10
if self.INITIAL_RESERVE_CARDS > 30:
yoffset = 5
# (piles up to 20 cards are playable in default window size)
h = max(3 * lay.YS, lay.YS + self.INITIAL_RESERVE_CARDS * yoffset)
if round_text:
h += lay.TEXT_HEIGHT
self.setSize(lay.XM + (2 + max(rows, 4 * decks)) * lay.XS + lay.XM,
lay.YM + lay.YS + lay.TEXT_HEIGHT + h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = self.Talon_Class(x,
y,
self,
max_rounds=max_rounds,
num_deal=num_deal)
lay.createText(s.talon, "s")
if round_text:
lay.createRoundText(s.talon, 'sss')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, "s")
x += lay.XM
y = lay.YM
for i in range(4):
for j in range(decks):
x += lay.XS
s.foundations.append(
self.Foundation_Class(x, y, self, i, mod=13, max_move=0))
if text:
if rows > 4 * decks:
tx, ty, ta, tf = lay.getTextAttr(None, "se")
tx, ty = x + tx + lay.XM, y + ty
else:
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x + tx, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = lay.XM, lay.YM + lay.YS + lay.TEXT_HEIGHT
if round_text:
y += lay.TEXT_HEIGHT
s.reserves.append(self.ReserveStack_Class(x, y, self))
s.reserves[0].CARD_YOFFSET = yoffset
x, y = lay.XM + 2 * lay.XS + lay.XM, lay.YM + lay.YS
if text:
y += lay.TEXT_HEIGHT
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x += lay.XS
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# create texts 1)
ta = "ss"
x, y = l.XM, l.YM + 2*l.YS
if self.preview <= 1:
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text=_('''\
Royal Flush
Straight Flush
Four of a Kind
Full House
Flush
Straight
Three of a Kind
Two Pair
One Pair'''))
self.texts.list.append(t)
bb = t.bbox()
x = bb[1][0] + 16
h = bb[1][1] - bb[0][1]
if h >= 2*l.YS:
ta = "e"
t.move(0, -l.YS)
y = y - l.YS
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="100\n75\n50\n25\n20\n15\n10\n5\n2")
self.texts.list.append(t)
x = t.bbox()[1][0] + 16
self.texts.misc = MfxCanvasText(
self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="0\n"*8+"0")
x = self.texts.misc.bbox()[1][0] + 32
# set window
w = max(2*l.XS, x)
self.setSize(l.XM + w + 5*l.XS + 50, l.YM + 5*l.YS + 30)
# create stacks
for i in range(5):
for j in range(5):
x, y = l.XM + w + j*l.XS, l.YM + i*l.YS
s.rows.append(self.RowStack_Class(x, y, self))
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, anchor=ta)
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
# create texts 2)
if self.preview <= 1:
for i in (4, 9, 14, 19, 24):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="e")
t = MfxCanvasText(self.canvas, tx+8, ty,
anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
for i in range(20, 25):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="ss")
t = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
self.texts.score = MfxCanvasText(
self.canvas, l.XM, 5*l.YS, anchor="sw",
font=self.app.getFont("canvas_large"))
# define hands for scoring
r = s.rows
self.poker_hands = [
r[0:5], r[5:10], r[10:15], r[15:20], r[20:25],
(r[0], r[0+5], r[0+10], r[0+15], r[0+20]),
(r[1], r[1+5], r[1+10], r[1+15], r[1+20]),
(r[2], r[2+5], r[2+10], r[2+15], r[2+20]),
(r[3], r[3+5], r[3+10], r[3+15], r[3+20]),
(r[4], r[4+5], r[4+10], r[4+15], r[4+20]),
]
self.poker_hands = map(tuple, self.poker_hands)
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self, rows=4, max_rounds=-1, num_deal=3,
text=True, round_text=False):
# create layout
lay, s = Layout(self), self.s
decks = self.gameinfo.decks
# set window
if self.INITIAL_RESERVE_FACEUP == 1:
yoffset = lay.YOFFSET # min(lay.YOFFSET, 14)
else:
yoffset = 10
if self.INITIAL_RESERVE_CARDS > 30:
yoffset = 5
# (piles up to 20 cards are playable in default window size)
h = max(3*lay.YS, lay.YS+self.INITIAL_RESERVE_CARDS*yoffset)
if round_text:
h += lay.TEXT_HEIGHT
self.setSize(
lay.XM + (2+max(rows, 4*decks))*lay.XS + lay.XM,
lay.YM + lay.YS + lay.TEXT_HEIGHT + h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = self.Talon_Class(x, y, self,
max_rounds=max_rounds, num_deal=num_deal)
lay.createText(s.talon, "s")
if round_text:
lay.createRoundText(s.talon, 'sss')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, "s")
x += lay.XM
y = lay.YM
for i in range(4):
for j in range(decks):
x += lay.XS
s.foundations.append(self.Foundation_Class(x, y, self, i,
mod=13, max_move=0))
if text:
if rows > 4 * decks:
tx, ty, ta, tf = lay.getTextAttr(None, "se")
tx, ty = x + tx + lay.XM, y + ty
else:
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x + tx, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = lay.XM, lay.YM + lay.YS + lay.TEXT_HEIGHT
if round_text:
y += lay.TEXT_HEIGHT
s.reserves.append(self.ReserveStack_Class(x, y, self))
s.reserves[0].CARD_YOFFSET = yoffset
x, y = lay.XM + 2 * lay.XS + lay.XM, lay.YM + lay.YS
if text:
y += lay.TEXT_HEIGHT
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x += lay.XS
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# create texts 1)
ta = "ss"
x, y = l.XM, l.YM + 2*l.YS
if self.preview <= 1:
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text=_('''\
Royal Flush
Straight Flush
Four of a Kind
Full House
Flush
Straight
Three of a Kind
Two Pair
One Pair'''))
self.texts.list.append(t)
bb = t.bbox()
x = bb[1][0] + 16
h = bb[1][1] - bb[0][1]
if h >= 2*l.YS:
ta = "e"
t.move(0, -l.YS)
y = y - l.YS
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="100\n75\n50\n25\n20\n15\n10\n5\n2")
self.texts.list.append(t)
x = t.bbox()[1][0] + 16
self.texts.misc = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="0\n"*8+"0")
x = self.texts.misc.bbox()[1][0] + 32
# set window
w = max(2*l.XS, x)
self.setSize(l.XM + w + 5*l.XS + 50, l.YM + 5*l.YS + 30)
# create stacks
for i in range(5):
for j in range(5):
x, y = l.XM + w + j*l.XS, l.YM + i*l.YS
s.rows.append(self.RowStack_Class(x, y, self))
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, anchor=ta)
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
# create texts 2)
if self.preview <= 1:
for i in (4, 9, 14, 19, 24):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="e")
t = MfxCanvasText(self.canvas, tx+8, ty,
anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
for i in range(20, 25):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="ss")
t = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
self.texts.score = MfxCanvasText(self.canvas, l.XM, 5*l.YS, anchor="sw",
font=self.app.getFont("canvas_large"))
# define hands for scoring
r = s.rows
self.poker_hands = [
r[0:5], r[5:10], r[10:15], r[15:20], r[20:25],
(r[0], r[0+5], r[0+10], r[0+15], r[0+20]),
(r[1], r[1+5], r[1+10], r[1+15], r[1+20]),
(r[2], r[2+5], r[2+10], r[2+15], r[2+20]),
(r[3], r[3+5], r[3+10], r[3+15], r[3+20]),
(r[4], r[4+5], r[4+10], r[4+15], r[4+20]),
]
self.poker_hands = map(tuple, self.poker_hands)
# define stack-groups
l.defaultStackGroups()
return l
self.setSize(x3, h)
# create stacks
y = l.YM
if reserves:
x = x1 - int(l.XS*(reserves-1)/2)
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
y += l.YS
x = x1
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, suit=i, max_move=0))
y += l.YS
if texts:
tx, ty, ta, tf = l.getTextAttr(None, "ss")
tx, ty = x+tx, y-l.YS+ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
for x in (x0, x2):
y = l.YM+l.YS*int(reserves!=0)
for i in range(4):
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
if reserves:
l.setRegion(s.rows[:4], (-999, l.YM+l.YS-l.CH/2, x1-l.CW/2, 999999))
def createGame(self):
# create layout
l, s = Layout(self), self.s
# create texts 1)
ta = "ss"
x, y = l.XM, l.YM + 2 * l.YS
# set window
w = max(2 * l.XS, x, ((self.NUM_RESERVE + 1) * l.XS) + (4 * l.XM))
self.setSize(l.XM + w + 4 * l.XS + 50, l.YM + 4 * l.YS + 30)
# create stacks
for i in range(4):
for j in range(4):
x, y = l.XM + w + j * l.XS, l.YM + i * l.YS
s.rows.append(self.RowStack_Class(x, y, self))
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, anchor=ta)
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
for i in range(self.NUM_RESERVE):
x, y = ((i + 1) * l.XS) + (2 * l.XM), l.YM
s.reserves.append(self.RESERVE_STACK(x, y, self))
# create texts 2)
if self.preview <= 1:
for i in (3, 7, 11, 15):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="e")
t = MfxCanvasText(self.canvas,
tx + 8,
ty,
anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
for i in range(12, 16):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="ss")
t = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
self.texts.score = MfxCanvasText(
self.canvas,
l.XM,
4 * l.YS,
anchor="sw",
font=self.app.getFont("canvas_large"))
# define hands for scoring
r = s.rows
self.cribbage_hands = [
r[0:4], r[4:8], r[8:12], r[12:16],
(r[0], r[0 + 4], r[0 + 8], r[0 + 12]),
(r[1], r[1 + 4], r[1 + 8], r[1 + 12]),
(r[2], r[2 + 4], r[2 + 8], r[2 + 12]),
(r[3], r[3 + 4], r[3 + 8], r[3 + 12])
]
self.cribbage_hands = list(map(tuple, self.cribbage_hands))
# define stack-groups
l.defaultStackGroups()
return l
