def createGame(self):
layout, s = Layout(self), self.s
self.setSize(
layout.XM+10*layout.XS, layout.YM+3*layout.YS+15*layout.YOFFSET)
x, y = layout.XM+layout.XS, layout.YM
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i//2))
x += layout.XS
x, y = layout.XM, layout.YM+layout.YS
for i in range(2):
for j in range(4):
s.rows.append(self.RowStack_Class(x, y, self))
x += layout.XS
x += 2*layout.XS
x, y = layout.XM+4*layout.XS, layout.YM+layout.YS
s.reserves += self._createFirTree(layout, x, y)
x, y = layout.XM, 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 = WasteStack(x, y, self)
layout.createText(s.waste, 'n')
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
layout, s = Layout(self), self.s
w = layout.XM + max(7*layout.XS, 2*layout.XS+23*layout.XOFFSET)
h = layout.YM + 5.5*layout.YS
self.setSize(w, h)
x, y = layout.XM+(w-7*layout.XS)//2, layout.YM
s.rows = self._createPyramid(layout, x, y, 7)
x, y = layout.XM, self.height-layout.YS
s.talon = WasteTalonStack(
x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3)
layout.createText(s.talon, "n")
x += layout.XS
s.waste = Pyramid_Waste(x, y, self, max_accept=1)
s.waste.CARD_XOFFSET = layout.XOFFSET
layout.createText(s.waste, "n")
x, y = self.width - layout.XS, layout.YM
s.foundations.append(self.Foundation_Class(x, y, self,
suit=ANY_SUIT, dir=0, base_rank=ANY_RANK,
max_move=0, max_cards=52))
layout.createText(s.foundations[0], 'nw')
layout.defaultStackGroups()
self.sg.openstacks.append(s.waste)
def createGame(self, rows=12, max_rounds=2, XOFFSET=0):
l, s = Layout(self), self.s
self.setSize(l.XM + (rows + 2) * l.XS, l.YM + 8 * l.YS)
x, y = l.XM, l.YM
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x += l.XS
for i in range(2):
y = l.YM
for j in range(8):
s.foundations.append(SS_FoundationStack(x, y, self,
suit=j % 4))
y += l.YS
x += l.XS
x, y = l.XM, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
l.createText(s.talon, 'n')
x += l.XS
s.waste = WasteStack(x, y, self)
s.waste.CARD_XOFFSET = XOFFSET
l.createText(s.waste, 'n')
if max_rounds > 1:
l.createRoundText(s.talon, 'nnn')
self.setRegion(s.rows,
(-999, -999, l.XM + rows * l.XS - l.CW // 2, 999999),
priority=1)
l.defaultStackGroups()
def createGame(self, rows=9, max_rounds=1, num_deal=1, playcards=16):
l, s = Layout(self), self.s
self.setSize(l.XM + 8 * l.XS,
l.YM + 3 * l.YS + 12 * l.YOFFSET + l.TEXT_HEIGHT)
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 += 2 * l.XS
stack = BastilleDay_BastilleStack(x, y, self)
s.reserves.append(stack)
l.createText(stack, 's')
x += l.XS
stack = OpenStack(x, y, self)
stack.CARD_XOFFSET = l.XOFFSET
l.createText(stack, 's')
s.reserves.append(stack)
x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4))
x = x + l.XS
x, y = l.XM, l.YM + 2 * l.YS + l.TEXT_HEIGHT
for i in range(8):
s.rows.append(AC_RowStack(x, y, self))
x = x + l.XS
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 8 * l.XS, l.YM + 2 * l.YS + 16 * l.YOFFSET)
# create stacks
x, y, = l.XM, l.YM
for i in range(8):
if self.Foundation_Class is RK_FoundationStack:
suit = ANY_SUIT
else:
suit = int(i // 2)
s.foundations.append(
self.Foundation_Class(x, y, self, suit=suit, max_move=0))
x += l.XS
x, y = l.XM, l.YM + l.YS
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
x += l.XS
s.waste = WasteStack(x, y, self, max_cards=1)
x += l.XS
for i in range(5):
stack = Numerica_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS)
# stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.rows.append(stack)
x = x + l.XS
# define stack-groups
l.defaultStackGroups()
def createGame(self, card_x_space=20):
# create layout
l, s = Layout(self, card_x_space=card_x_space), self.s
# set window
max_x = max([i[0] for i in self.FOUNDATIONS_LAYOUT+self.ROWS_LAYOUT])
max_y = max([i[1] for i in self.FOUNDATIONS_LAYOUT+self.ROWS_LAYOUT])
self.setSize((3+max_x)*l.XS+l.XM, (1+max_y)*l.YS+l.YM+l.YM)
# create stacks
x = l.XM
y = l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
x0, y0 = x + l.XS, y
for d in self.ROWS_LAYOUT:
x, y = x0 + d[0] * l.XS, y0 + d[1] * l.YS
stack = self.RowStack_Class(x, y, self)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
x, y = x0 + 2 * l.XS, y0 + 2 * l.YS
fnd_cls = self.Foundation_Classes[0]
s.foundations.append(fnd_cls(x, y, self))
fnd_cls = self.Foundation_Classes[1]
for d in self.FOUNDATIONS_LAYOUT:
x, y = x0 + d[0] * l.XS, y0 + d[1] * l.YS
s.foundations.append(fnd_cls(x, y, self))
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=4):
# create layout
lay, s = Layout(self), self.s
# set window
max_rows = max(7, rows + 3)
w, h = lay.XM + max_rows * lay.XS, lay.YM + 2 * lay.YS + 12 * lay.YOFFSET
self.setSize(w, h)
# create stacks
y = lay.YM + lay.YS + lay.TEXT_HEIGHT
for x in (lay.XM, w - lay.XS):
stack = self.ReserveStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, lay.YOFFSET
s.reserves.append(stack)
x, y = lay.XM + (max_rows - 4) * lay.XS, lay.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += lay.XS
x, y = lay.XM + (max_rows -
rows) * lay.XS // 2, lay.YM + lay.YS + lay.TEXT_HEIGHT
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x += lay.XS
s.talon = WasteTalonStack(lay.XM, lay.YM, self, max_rounds=1)
lay.createText(s.talon, "s")
s.waste = WasteStack(lay.XM + lay.XS, lay.YM, self)
lay.createText(s.waste, "s")
# define stack-groups
lay.defaultStackGroups()
return lay
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 12 * l.XS,
l.YM + max(4.5 * l.YS, 2 * l.YS + 12 * 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 += 2 * l.XS
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 * 3 // 2
for i in range(3):
s.reserves.append(ReserveStack(x, y, self))
y += l.YS
x, y = l.XM + 2 * l.XS, l.YM + l.YS
for i in range(10):
s.rows.append(SS_RowStack(x, y, self, max_move=1))
x += l.XS
l.defaultStackGroups()
def createGame(self, rows=7):
l, s = Layout(self), self.s
self.setSize(l.XM + 10 * l.XS, l.YM + 3 * l.YS + 12 * l.YOFFSET)
y = l.YM
for i in range(2):
x = l.XM + 2 * l.XS
for j in range(8):
s.foundations.append(
self.Foundation_Class(x, y, self, suit=j % 4))
x += l.XS
y += l.YS
x, y = l.XM + (10 - rows) * l.XS // 2, l.YM + 2 * l.YS
for i in range(rows):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'ne')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
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 + l.TEXT_HEIGHT)
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 += l.XS
for i in range(8):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i % 4, max_cards=12))
x += l.XS
x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT
s.foundations.append(
RK_FoundationStack(x,
y,
self,
suit=ANY_SUIT,
base_rank=KING,
dir=0,
max_cards=8))
x += 3 * l.XS
for i in range(6):
s.rows.append(RK_RowStack(x, y, self, max_move=1))
x += l.XS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
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
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += l.XS
x, y = l.XM, l.YM
s.talon = WasteTalonStack(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')
y = 2 * l.YM + l.YS
for i in range(2):
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
s.rows.append(stack)
x += l.XS
y += l.YS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 6 * l.XS, l.YM + 2 * l.YS)
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x,
y,
self,
max_rounds=UNLIMITED_REDEALS,
num_deal=3)
l.createText(s.talon, 'ne')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
x = l.XM + 2 * l.XS
for i in range(4):
y = l.YM
s.foundations.append(SS_FoundationStack(x, y, self, i, max_move=0))
y += l.YS
s.foundations.append(
SS_FoundationStack(x,
y,
self,
i,
base_rank=KING,
max_move=0,
dir=-1))
x += l.XS
l.defaultStackGroups()
def createGame(self, max_rounds=1):
# create layout
l, s = Layout(self), self.s
# set window
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
for i in range(8):
s.foundations.append(self.Foundation_Class(x, y, self, suit=i / 2))
x = x + l.XS
x, y = l.XM, y + l.YS
for i in range(8):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
x, y, = l.XM, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
l.createText(s.talon, "n")
if max_rounds > 1:
l.createRoundText(self.s.talon, 'nnn')
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "n")
# define stack-groups
l.defaultStackGroups()
def createGame(self, max_rounds=1):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 7 * l.XS, l.YM + 4 * l.YS)
# create stacks
x = l.XM + 4 * l.XS
for fnd_cls in self.Foundation_Classes:
y = l.YM
for i in range(4):
s.foundations.append(fnd_cls(x, y, self, suit=i))
y += l.YS
x += l.XS
for i in range(4):
for j in range(2):
x, y = l.XM + (3 + 3 * j) * l.XS, l.YM + i * l.YS
stack = self.RowStack_Class(x, y, self)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x, y, = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
if max_rounds > 1:
l.createRoundText(s.talon, 'ne', dx=l.XS)
# define stack-groups
l.defaultStackGroups()
def createGame(self, max_rounds=3):
# create layout
l, s = Layout(self, card_x_space=20, card_y_space=20), self.s
# set window
self.setSize(5*l.XS+l.XM, 4*l.YS+3*l.YM)
# create stacks
x, y = l.XM+1.5*l.XS, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
l.createText(s.talon, "sw")
if max_rounds > 1:
l.createRoundText(self.s.talon, 'nw')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "se")
x0, y0 = l.XM, l.YM+l.YS
i = 0
for d in ((0, 0), (4, 0), (0, 2), (4, 2)):
x, y = x0+d[0]*l.XS, y0+d[1]*l.YS
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
max_move=0, mod=13))
i += 1
for d in ((2, 0), (1, 1), (2, 1), (3, 1), (2, 2)):
x, y = x0+d[0]*l.XS, y0+d[1]*l.YS
stack = self.RowStack_Class(x, y, self)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
# Set window size
self.setSize(l.XM + l.XS * 8, l.YM + l.YS * 5)
# Create foundations
x = l.XM + l.XS * 3
y = l.YM
for i in range(4):
s.foundations.append(
ImperialTrump_Foundation(x, y, self, i, max_cards=14))
x = x + l.XS
s.foundations.append(SS_FoundationStack(x, y, self, 4, max_cards=22))
# Create talon
x = l.XM
s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=-1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# Create rows
x = l.XM
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
self.setRegion(s.rows, (-999, y, 999999, 999999))
# Define stack groups
l.defaultStackGroups()
def createGame(self, max_rounds=2):
l, s = Layout(self), self.s
self.setSize(l.XM+8*l.XS, l.YM+4*l.YS)
self.base_card = None
i = 0
for x, y in ((l.XM, l.YM),
(l.XM+7*l.XS, l.YM),
(l.XM, l.YM+3*l.YS),
(l.XM+7*l.XS, l.YM+3*l.YS),
):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, mod=13))
i += 1
y = l.YM+l.YS
for i in range(2):
x = l.XM+l.XS
for j in range(6):
stack = AC_RowStack(x, y, self, max_move=1, mod=13)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
s.rows.append(stack)
x += l.XS
y += l.YS
x, y = l.XM+3*l.XS, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'sw')
x += l.XS
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 + 10 * l.XS, l.YM + 5 * l.YS)
x, y = l.XM, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
s.foundations.append(
SS_FoundationStack(x + 6 * l.XS, y, self, suit=i))
x += l.XS
x, y = l.XM + 4 * l.XS, l.YM
r = list(range(11))
for i in range(5, 0, -1):
for j in r[i:-i]:
x, y = l.XM + (j - 0.5) * l.XS, l.YM + (5 - i) * l.YS
s.rows.append(BasicRowStack(x, y, self, max_accept=0))
x, y = l.XM, l.YM + 1.5 * l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'ne')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
l.defaultStackGroups()
def createGame(self):
# create layout
lay, s = Layout(self), self.s
# set window
w = max(8 * lay.XS, 6 * lay.XS + 8 * lay.XOFFSET)
h = lay.YM + 3 * lay.YS + 12 * lay.YOFFSET
self.setSize(w + lay.XM, h)
# create stacks
y = lay.YM
for x in (lay.XM, lay.XM + w - lay.XS - 4 * lay.XOFFSET):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
s.reserves.append(stack)
x, y = lay.XM + (w - 4 * lay.XS) // 2, lay.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += lay.XS
x, y = lay.XM + (w - 8 * lay.XS) // 2, lay.YM + lay.YS
for i in range(8):
s.rows.append(AC_RowStack(x, y, self))
x += lay.XS
s.talon = WasteTalonStack(lay.XM, h - lay.YS, self, max_rounds=1)
lay.createText(s.talon, "n")
s.waste = WasteStack(lay.XM + lay.XS, h - lay.YS, self)
lay.createText(s.waste, "n")
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 8 * l.XS, l.YM + 5 * l.YS)
y = l.YM
for i in range(5):
x = l.XM + (8 - i) * l.XS // 2
for j in range(i + 1):
s.rows.append(ReserveStack(x, y, self))
x += l.XS
y += l.YS
suit = 0
for xx, yy in ((1.5, 1.5), (1, 2.5), (6.5, 1.5), (7, 2.5)):
x, y = l.XM + xx * l.XS, l.YM + yy * l.YS
s.foundations.append(SS_FoundationStack(x, y, self, suit))
suit += 1
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')
l.defaultStackGroups()
def createGame(self):
lay, s = Layout(self), self.s
w, h = lay.XM + 6*lay.XS + 4*lay.XOFFSET, \
lay.YM + lay.TEXT_HEIGHT + 2*lay.YS + 12*lay.YOFFSET
self.setSize(w, h)
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
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')
x += lay.XS + 4 * lay.XOFFSET
y = lay.YM
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, suit=i))
x += lay.XS
x0, y0, w = lay.XM, lay.YM+lay.YS+2*lay.TEXT_HEIGHT,\
lay.XS+2*lay.XOFFSET
for i, j in ((0, 0), (0, 1), (1, 0), (1, 1)):
x, y = x0 + i * w, y0 + j * lay.YS
stack = self.ReserveStack_Class(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
s.reserves.append(stack)
x, y = lay.XM + 2 * lay.XS + 4 * lay.XOFFSET, lay.YM + lay.YS
for i in range(4):
s.rows.append(self.RowStack_Class(x, y, self))
x += lay.XS
lay.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 5.5 * l.XS, l.YM + 4 * l.YS)
x, y = l.XM, l.YM + l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, 'ne')
l.createRoundText(s.talon, 'nn')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
x, y = l.XM + 1.5 * 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 + 1.5 * 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 = l.XM + 1.5 * 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=JACK))
x += l.XS
x = l.XM + 1.5 * 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))
x += l.XS
l.defaultStackGroups()
def createGame(self, rows=9):
l, s = Layout(self), self.s
self.setSize(l.XM+11*l.XS, l.YM+4*l.YS+12*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')
y = l.YM
for i in range(2):
x = l.XM+2.5*l.XS
for j in range(8):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=j % 4, max_move=1))
x += l.XS
y += l.YS
x, y = l.XM, l.YM+2*l.YS
stack = ReserveStack(x, y, self, max_cards=8)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
l.createText(stack, 'n')
x, y = l.XM+2*l.XS, l.YM+2*l.YS
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self, max_move=1, base_rank=KING))
x += l.XS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 5 * l.XS, l.YM + 5 * l.YS)
suit = 0
for x, y in ((0, 0), (4, 0), (0, 4), (4, 4)):
x, y = l.XM + x * l.XS, l.YM + y * l.YS
s.foundations.append(SS_FoundationStack(x, y, self, suit=suit))
suit += 1
x, y = l.XM + 3 * l.XS // 2, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'nw')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
y = l.YM + l.YS
for i in range(3):
x = l.XM + l.XS
for j in range(3):
stack = CornerSuite_RowStack(x, y, self, max_move=1)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
x += l.XS
y += l.YS
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 8 * l.XS, l.YM + 2 * l.YS + 16 * l.YOFFSET)
# create stacks
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, max_cards=1)
x += l.XS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += l.XS
x, y = l.XM + 2 * l.XS, l.YM + l.YS
for i in range(4):
s.rows.append(
Numerica_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS))
x += l.XS
x = l.XM + 6 * l.XS
for i in range(2):
y = l.YM + l.YS // 2
for j in range(3):
s.reserves.append(OpenStack(x, y, self, max_accept=0))
y += l.YS
x += l.XS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 5 * l.XS, l.YM + 4 * l.YS)
for i, j in (
(1, 0),
(2, 0),
(3, 0),
(4, 1.5),
(3, 3),
(2, 3),
(1, 3),
(0, 1.5),
):
x, y = l.XM + i * l.XS, l.YM + j * l.YS
stack = RK_RowStack(x, y, self, dir=1, mod=13, max_move=0)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x, y = l.XM + 1.5 * l.XS, l.YM + 1.5 * l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, 'nw')
l.createRoundText(self.s.talon, 'nn')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
l.defaultStackGroups()
def createGame(self):
# create layout
layout, s = Layout(self), self.s
# set window
self.setSize(7*layout.XS+layout.XM, 5*layout.YS+layout.YM)
# create stacks
for i in range(7):
x = layout.XM + (6-i) * layout.XS // 2
y = layout.YM + layout.YS + i * layout.YS // 2
for j in range(i+1):
s.rows.append(Pyramid_RowStack(x, y, self))
x = x + layout.XS
x, y = layout.XM, layout.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
layout.createText(s.talon, "s")
x = x + layout.XS
s.waste = Pyramid_Waste(x, y, self, max_accept=1)
layout.createText(s.waste, "s")
s.waste.CARD_XOFFSET = 14
x, y = self.width - layout.XS, layout.YM
s.foundations.append(Pyramid_Foundation(x, y, self,
suit=ANY_SUIT, dir=0, base_rank=ANY_RANK,
max_move=0, max_cards=52))
# define stack-groups
self.sg.talonstacks = [s.talon] + [s.waste]
self.sg.openstacks = s.rows + self.sg.talonstacks
self.sg.dropstacks = s.rows + self.sg.talonstacks
def createGame(self):
# create layout
l, s = Layout(self, card_x_space=20, card_y_space=20), self.s
# set window
self.setSize(5*l.XS+l.XM, 3*l.YS+l.YM+l.YM)
# create stacks
x = l.XM
y = l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
x0, y0 = x + l.XS, y
for d in ((0, 1), (1, 0), (1, 2), (2, 1)):
x, y = x0 + d[0] * l.XS, y0 + d[1] * l.YS
s.rows.append(Windmill_RowStack(x, y, self))
x, y = x0 + l.XS, y0 + l.YS
s.foundations.append(Windmill_Foundation(x, y, self, base_rank=5,
mod=13, max_cards=24, dir=-1))
for d in ((0.1, 0.1), (1.9, 0.1), (0.1, 1.9), (1.9, 1.9)):
x, y = x0 + d[0] * l.XS, y0 + d[1] * l.YS
s.foundations.append(Windmill_Foundation(x, y, self,
max_cards=7, base_rank=6, mod=13))
# define stack-groups
l.defaultStackGroups()
def createGame(self, max_rounds=-1, num_deal=1, **layout):
# create layout
l, s = Layout(self), self.s
kwdefault(layout, rows=9, waste=1, texts=1, playcards=19)
self.Layout_Method(l, **layout)
self.setSize(l.size[0], l.size[1])
# create stacks
s.talon = WasteTalonStack(l.s.talon.x,
l.s.talon.y,
self,
max_rounds=max_rounds,
num_deal=num_deal)
s.waste = WasteStack(l.s.waste.x, l.s.waste.y, self)
for r in l.s.foundations:
s.foundations.append(
self.Foundation_Class(r.x, r.y, self, suit=r.suit))
for r in l.s.rows:
s.rows.append(self.RowStack_Class(r.x, r.y, self))
# default
l.defaultAll()
# extra
if max_rounds > 1:
anchor = 'nn'
if layout.get("texts"):
anchor = 'nnn'
l.createRoundText(s.talon, anchor)
return l
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()
