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):
# 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):
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# Set window size
self.setSize(7 * l.XS, 5 * l.YS + 3 * l.YM)
# Four winds
TEXTS = (_("North"), _("East"), _("South"), _("West"),
_("NW"), _("NE"), _("SE"), _("SW"))
# Create foundations
x = l.XM * 3
y = l.YM
xoffset = (2.5, 5, 2.5, 0)
yoffset = (0, 2, 4, 2)
for i in range(4):
x0 = x + (xoffset[i] * l.XS)
y0 = y + (yoffset[i] * l.YS)
stack = FourWinds_Foundation(x0, y0, self, -1,
max_cards=12, max_accept=1,
base_rank=i)
s.foundations.append(stack)
t = MfxCanvasText(self.canvas, x0 + l.CW / 2, y0 + l.YS + 5,
anchor="center", font=font,
text=TEXTS[i])
stack.texts.misc = t
# Create rows
xoffset = (1.25, 3.75, 3.75, 1.25)
yoffset = (0.75, 0.75, 3, 3)
for i in range(4):
x0 = x + (xoffset[i] * l.XS)
y0 = y + (yoffset[i] * l.YS)
stack = FourWinds_RowStack(x0, y0, self, yoffset=10,
max_cards=3, max_accept=1,
base_rank=ANY_RANK)
s.rows.append(stack)
t = MfxCanvasText(self.canvas, x0 + l.CW / 2, y0 + l.YS + 5,
anchor="center", font=font,
text=TEXTS[i+4])
stack.texts.misc = t
self.setRegion(s.rows, (x + l.XS, y + l.YS * 0.65, x + l.XS * 4 + 5,
y + l.YS * 3 + 5))
# Create talon
x = x + 2 * l.XS
y = y + 2 * l.YS
s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=2)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# Define stack-groups
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):
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
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):
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):
lay = Bastion.createGame(self)
self.base_rank = None
tx, ty, ta, tf = lay.getTextAttr(self.s.foundations[-1], 'se')
font = self.app.getFont('canvas_default')
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
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), self.s
# set window
# compute best XOFFSET
xoffset = int(l.XS * 8 / self.gameinfo.ncards)
if xoffset < l.XOFFSET:
l.XOFFSET = xoffset
# Set window size
w, h = l.XM + l.XS * 10, l.YM + l.YS * 4
self.setSize(w, h)
# Extra settings
self.game_score = 52
self.hand_score = self.sequence = 0
self.peaks = [0] * 3
# Create rows
x, y = l.XM + l.XS * 1.5, l.YM
for i in range(3):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS * 3
x, y = l.XM + l.XS, y + l.YS * .5
for i in range(3):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS * 2
x, y = l.XM + l.XS * .5, y + l.YS * .5
for i in range(9):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
x, y = l.XM, y + l.YS * .5
for i in range(10):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
# Create talon
x, y = l.XM, y + l.YM + l.YS
s.talon = ThreePeaks_TalonStack(x, y, self, num_deal=1, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = self.Waste_Class(x, y, self)
s.waste.CARD_XOFFSET = l.XOFFSET
s.foundations.append(s.waste)
l.createText(s.waste, "s")
# Create text for scores
if self.preview <= 1:
self.texts.info = MfxCanvasText(
self.canvas,
l.XM + l.XS * 3,
h - l.YM,
anchor="sw",
font=self.app.getFont("canvas_default"))
# Define stack groups
l.defaultStackGroups()
def createGame(self):
layout, s = Layout(self), self.s
self.rank = -1
self.deadDeals = 1
self.max_rounds = VARIABLE_REDEALS
self.setSize(layout.XM + 4 * layout.XS, layout.YM + 2 * layout.YS)
x, y = layout.XM + 3 * layout.XS // 2, layout.YM
stack = HitOrMiss_Foundation(x, y, self, ANY_SUIT,
dir=0, mod=13, max_move=0, max_cards=52)
s.foundations.append(stack)
layout.createText(stack, 'ne')
x, y = layout.XM+layout.XS, layout.YM+layout.YS
s.talon = HitOrMiss_Talon(x, y, self,
max_rounds=VARIABLE_REDEALS, num_deal=1)
layout.createText(s.talon, 'nw')
x += layout.XS
s.waste = HitOrMiss_Waste(x, y, self)
layout.createText(s.waste, 'ne')
x += layout.XS * 1.1
y = layout.YM + 1.4 * layout.YS
if self.preview <= 1:
self.texts.base_rank = \
MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_large"))
# define stack-groups
layout.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):
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, 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+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):
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):
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):
lay = Fortress.createGame(self)
tx, ty, ta, tf = lay.getTextAttr(self.s.foundations[-1], "e")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx + lay.XM,
ty,
anchor=ta,
font=font)
def createText(self, stack, anchor, dx=0, dy=0, text_format=""):
if self.canvas.preview > 1:
return
assert stack.texts.ncards is None
tx, ty, ta, tf = self.getTextAttr(stack, anchor)
font = self.game.app.getFont("canvas_default")
stack.texts.ncards = MfxCanvasText(self.canvas, tx+dx, ty+dy,
anchor=ta, font=font)
stack.texts.ncards.text_format = text_format or tf
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):
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# Set window size
self.setSize(l.XM + l.XS * 11, l.YS * 6)
# Create foundations
id = 0
for j in range(4):
x, y = l.XM + l.XS * 8, l.YM * 3 + l.YS * j * 1.5
for i in range(3):
stack = Pagoda_Foundation(x, y, self, id)
s.foundations.append(stack)
t = MfxCanvasText(self.canvas,
x + l.CW // 2,
y - 12,
anchor="center",
font=font)
stack.texts.misc = t
x = x + l.XS
id = id + 1
# Build pagoda
x, y = l.XM + l.XS, l.YM
d = (0.4, 0.25, 0, 0.25, 0.4)
for i in range(5):
s.reserves.append(ReserveStack(x + l.XS * i, y + l.YS * d[i],
self))
x, y = l.XM + l.XS * 2, y + l.YS * 1.1
d = (0.25, 0, 0.25)
for i in range(3):
s.reserves.append(ReserveStack(x + l.XS * i, y + l.YS * d[i],
self))
x, y = l.XM, y + l.YS * 1.1
d = (0.5, 0.4, 0.25, 0, 0.25, 0.4, 0.5)
for i in range(7):
s.reserves.append(ReserveStack(x + l.XS * i, y + l.YS * d[i],
self))
x, y = l.XM + l.XS, y + l.YS * 1.5
for i in range(5):
s.reserves.append(ReserveStack(x + l.XS * i, y, self))
# Create talon
x = l.XM + l.XS * 2.5
y = l.YM + l.YS * 4.9
s.talon = WasteTalonStack(x, y, self, num_deal=4, max_rounds=1)
l.createText(s.talon, "sw")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "se")
# Define stack groups
l.defaultStackGroups()
def createGame(self, max_rounds=1, num_deal=1):
lay = Canfield.createGame(self,
max_rounds=max_rounds,
num_deal=num_deal)
self.texts.score = MfxCanvasText(self.canvas,
8,
self.height - 8,
anchor="sw",
font=self.app.getFont("canvas_large"))
return lay
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):
# create layout
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# set window
# (piles up to 20 cards are playable - needed for Braid_BraidStack)
decks = self.gameinfo.decks
h = max(4 * l.YS + 30, l.YS + (self.BRAID_CARDS - 1) * l.YOFFSET)
self.setSize(l.XM + (8 + decks) * l.XS, l.YM + h)
# extra settings
self.base_card = None
# create stacks
s.addattr(braid=None) # register extra stack variable
x, y = l.XM, l.YM
for i in range(2):
s.rows.append(Braid_RowStack(x + 0.5 * l.XS, y, self))
s.rows.append(Braid_RowStack(x + 4.5 * l.XS, y, self))
y = y + 3 * l.YS
y = l.YM + l.YS
for i in range(2):
s.rows.append(Braid_ReserveStack(x, y, self))
s.rows.append(Braid_ReserveStack(x + l.XS, y, self))
s.rows.append(Braid_ReserveStack(x, y + l.YS, self))
s.rows.append(Braid_ReserveStack(x + l.XS, y + l.YS, self))
x = x + 4 * l.XS
x, y = l.XM + l.XS * 5 // 2, l.YM
s.braid = Braid_BraidStack(x, y, self)
x, y = l.XM + 7 * l.XS, l.YM + l.YS * 3 // 2
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, "s")
l.createRoundText(s.talon, 'nn')
x -= l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
y = l.YM
for i in range(4):
x = l.XM + 8 * l.XS
for cl in self.Foundation_Classes:
s.foundations.append(cl(x, y, self, suit=i))
x += l.XS
y = y + l.YS
x = l.XM + 8 * l.XS + decks * l.XS // 2
self.texts.info = MfxCanvasText(self.canvas,
x,
y,
anchor="n",
font=font)
# define stack-groups
self.sg.talonstacks = [s.talon] + [s.waste]
self.sg.openstacks = s.foundations + s.rows
self.sg.dropstacks = [s.braid] + s.rows + [s.waste]
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 defaultText(self, layout_stack):
if self.canvas.preview > 1:
return None
# print layout_stack, layout_stack.text_args
if layout_stack is None or not layout_stack.text_args:
return None
layout_stack.text_args["font"] = \
self.game.app.getFont("canvas_default")
t = MfxCanvasText(self.game.canvas, **layout_stack.text_args)
t.text_format = layout_stack.text_format
return t
def createGame(self):
layout = Rushdike.createGame(self)
help = (_('''\
Club: A 2 3 4 5 6 7 8 9 T J Q K
Spade: 2 4 6 8 T Q A 3 5 7 9 J K
Heart: 3 6 9 Q 2 5 8 J A 4 7 T K
Diamond: 4 8 Q 3 7 J 2 6 T A 5 9 K'''))
self.texts.help = MfxCanvasText(self.canvas,
layout.XM, self.height - layout.YM,
text=help,
anchor="sw",
font=self.app.getFont("canvas_fixed"))
def prepareView(self):
ReserveStack.prepareView(self)
if not self.is_visible or self.game.preview > 1:
return
images = self.game.app.images
x, y = self.x + images.CARDW // 2, self.y + images.CARDH // 2
self.texts.misc = MfxCanvasText(
self.game.canvas,
x,
y,
anchor="center",
font=self.game.app.getFont("canvas_default"))
def createGame(self):
lay = LittleGate.createGame(self, rows=5)
king_stack, queen_stack = self.s.reserves
tx, ty, ta, tf = lay.getTextAttr(king_stack, "s")
font = self.app.getFont("canvas_default")
king_stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font,
text=_('King'))
tx, ty, ta, tf = lay.getTextAttr(queen_stack, "s")
font = self.app.getFont("canvas_default")
queen_stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font,
text=_('Queen'))
king_stack.cap.base_rank = KING
queen_stack.cap.base_rank = QUEEN
