def createGame(self, rows=1, reserves=8, playcards=3):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM + 8 * l.XS, l.YM + 3.5 * l.YS + playcards * l.YOFFSET
h += l.TEXT_HEIGHT
self.setSize(w, h)
# create stacks
x, y, = l.XM, l.YM
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, max_move=0))
x = x + l.XS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i,
max_move=0,
base_rank=KING,
dir=-1))
x = x + l.XS
x, y, = l.XM + (8 - reserves) * l.XS / 2, y + l.YS
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x = x + l.XS
x, y = l.XM + (8 - 1 - rows) * l.XS / 2, self.height - l.YS
s.talon = Alhambra_Talon(x, y, self, max_rounds=3)
if rows == 1:
l.createText(s.talon, 'sw')
else:
l.createText(s.talon, 'n')
anchor = 'nn'
if rows > 1:
anchor = 'nnn'
l.createRoundText(s.talon, anchor)
x += l.XS
for i in range(rows):
stack = self.RowStack_Class(x, y, self, mod=13, max_accept=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
s.rows.append(stack)
x += l.XS
if rows == 1:
l.createText(stack, 'se')
else:
l.createText(stack, 'n')
# define stack-groups (non default)
l.defaultStackGroups()
def createGame(self, rows=1, reserves=8, playcards=3):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM+8*l.XS, l.YM+3.5*l.YS+playcards*l.YOFFSET
h += l.TEXT_HEIGHT
self.setSize(w, h)
# create stacks
x, y, = l.XM, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
max_move=0))
x += l.XS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
max_move=0, base_rank=KING, dir=-1))
x += l.XS
x, y, = l.XM+(8-reserves)*l.XS//2, y+l.YS
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
x, y = l.XM+(8-1-rows)*l.XS//2, self.height-l.YS
s.talon = Alhambra_Talon(x, y, self, max_rounds=3)
if rows == 1:
l.createText(s.talon, 'sw')
else:
l.createText(s.talon, 'n')
anchor = 'nn'
if rows > 1:
anchor = 'nnn'
l.createRoundText(s.talon, anchor)
x += l.XS
for i in range(rows):
stack = self.RowStack_Class(x, y, self, mod=13, max_accept=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
s.rows.append(stack)
x += l.XS
if rows == 1:
l.createText(stack, 'se')
else:
l.createText(stack, 'n')
# define stack-groups (non default)
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):
# 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):
# 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, rows=8, reserves=8, playcards=7):
# create layout
l, s = Layout(self), self.s
# set window
max_rows = max(rows, reserves)
w, h = l.XM + max_rows*l.XS, l.YM + 2*l.YS + (12+playcards)*l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM + (max_rows-rows)*l.XS//2, l.YM
for i in range(rows):
stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
x += l.XS
x, y = l.XM + (max_rows-reserves)*l.XS//2, l.YM+l.YS+12*l.YOFFSET
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
x += l.XS
s.talon = InitialDealTalonStack(l.XM, l.YM, self)
# default
l.defaultAll()
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, rows=8, reserves=8, playcards=7):
# create layout
l, s = Layout(self), self.s
# set window
max_rows = max(rows, reserves)
w, h = l.XM + max_rows * l.XS, l.YM + 2 * l.YS + (
12 + playcards) * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM + (max_rows - rows) * l.XS // 2, l.YM
for i in range(rows):
stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
x += l.XS
x, y = l.XM + (max_rows -
reserves) * l.XS // 2, l.YM + l.YS + 12 * l.YOFFSET
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
x += l.XS
s.talon = InitialDealTalonStack(l.XM, l.YM, self)
# default
l.defaultAll()
def createGame(self):
# 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 + 13 * l.XOFFSET)
self.setSize(l.XM + 2 * w + 2 * l.XS, l.YM + 5 * l.YS + l.TEXT_HEIGHT)
# create stacks
x, y = l.XM, l.YM + 4 * l.YS
s.talon = InitialDealTalonStack(x, y, self)
x, y = l.XM + w - l.XS, self.height - l.YS
for i in range(4):
stack = OpenStack(x, y, self, max_accept=0)
s.reserves.append(stack)
l.createText(stack, 'n')
x += l.XS
x = l.XM + w
for x in (l.XM + w, l.XM + w + l.XS):
y = l.YM
for i in range(4):
s.foundations.append(RK_FoundationStack(x, y, self,
max_move=0))
y += l.YS
for x in (l.XM, l.XM + w + 2 * l.XS):
y = l.YM
for i in range(4):
stack = RK_RowStack(x,
y,
self,
max_move=1,
max_accept=1,
base_rank=ANY_RANK)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
l.setRegion(s.rows[:4],
(-999, -999, w - l.CW // 2, l.YM + 4 * l.YS - l.CH // 2))
# define stack-groups
l.defaultStackGroups()
# set regions
l.defaultRegions()
def createGame(self):
# create layout
l, s = Layout(self), self.s
ROWS = 7
# set size so that at least 2//3 of a card is visible with 20 cards
h = l.CH * 2 // 27 * l.YOFFSET
h = l.YM + max(h, 5 * l.YS)
# create rows
x, y = l.XM, l.YM
w1, w2 = (7 * (l.XS + l.XM)), (2 * l.XS)
if w2 + 13 * l.XOFFSET > w1:
l.XOFFSET = int((w1 - w2) / 13)
reserve = OpenStack(x * 3, y, self)
reserve.CARD_XOFFSET = l.XOFFSET
l.createText(reserve, "sw")
s.reserves.append(reserve)
y += l.YS
for i in range(ROWS):
self.s.rows.append(self.RowStack_Class(x, y, self))
x += l.XS
# Don't know why this is necessary for the Yukon layout.
# But we should probably figure out how to get this to work
# like other games.
self.setRegion(self.s.rows, (-999, -999, x - l.CW // 2, 999999))
# create foundations
y = l.YM
for suit in range(4):
self.s.foundations.append(self.Foundation_Class(
x, y, self, suit=suit, max_move=0))
y += l.YS
x, y = l.XM, h - l.YS
self.s.talon = self.Talon_Class(x, y, self)
# set window
self.setSize(l.XM + 8 * l.XS, h)
l.defaultAll()
def createGame(self, rows=4, max_rounds=1, num_deal=1):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + (8.5 * l.XS), l.YM + (3 * l.YS))
# create stacks
x, y = l.XM, l.YM
for i in range(2):
stack = OpenStack(x, y, self)
stack.CARD_XOFFSET = l.XOFFSET
l.createText(stack, "sw")
s.reserves.append(stack)
x += 4.5 * l.XS
x, y = l.XM, y + l.YS
for i in range(4):
s.foundations.append(
RK_FoundationStack(x, y, self, suit=i, base_rank=ACE, dir=1))
x = x + l.XS
x = x + (l.XS / 2)
for i in range(4):
s.foundations.append(
RK_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1))
x = x + l.XS
x, y = l.XM + l.XS, y + l.YS
s.talon = WasteTalonStack(x,
y,
self,
max_rounds=max_rounds,
num_deal=num_deal)
l.createText(s.talon, "sw")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "se", text_format="%D")
x += 2.5 * l.XS
for i in range(rows):
s.rows.append(AcesAndKings_RowStack(x, y, self, max_accept=1))
x = x + l.XS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# 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+13*l.XOFFSET)
self.setSize(l.XM+2*w+2*l.XS, l.YM + 5*l.YS + l.TEXT_HEIGHT)
# create stacks
x, y = l.XM, l.YM+4*l.YS
s.talon = InitialDealTalonStack(x, y, self)
x, y = l.XM+w-l.XS, self.height-l.YS
for i in range(4):
stack = OpenStack(x, y, self, max_accept=0)
s.reserves.append(stack)
l.createText(stack, 'n')
x += l.XS
x = l.XM + w
for x in (l.XM + w, l.XM + w + l.XS):
y = l.YM
for i in range(4):
s.foundations.append(RK_FoundationStack(x, y, self,
max_move=0))
y += l.YS
for x in (l.XM, l.XM + w + 2*l.XS):
y = l.YM
for i in range(4):
stack = RK_RowStack(
x, y, self, max_move=1, max_accept=1, base_rank=ANY_RANK)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
l.setRegion(s.rows[:4], (-999, -999, w-l.CW//2, l.YM+4*l.YS-l.CH//2))
# define stack-groups
l.defaultStackGroups()
# set regions
l.defaultRegions()
def createGame(self, reserves=3, rows=5):
# create layout
l, s = Layout(self), self.s
# set window
n = 52 // reserves + 1
w, h = l.XM + (reserves + rows +
1) * l.XS, l.YM + 2 * l.YS + n * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM + (reserves + rows + 1 - 4) * l.XS // 2, l.YM
for i in range(4):
if self.Foundation_Class is RK_FoundationStack:
suit = ANY_SUIT
else:
suit = i
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
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
x += l.XS
for i in range(rows):
s.rows.append(
Gloaming_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS))
x += l.XS
s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self)
# default
l.defaultAll()
def createGame(self, reserves=3, rows=5):
# create layout
l, s = Layout(self), self.s
# set window
n = 52//reserves+1
w, h = l.XM + (reserves+rows+1)*l.XS, l.YM + 2*l.YS+n*l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM+(reserves+rows+1-4)*l.XS//2, l.YM
for i in range(4):
if self.Foundation_Class is RK_FoundationStack:
suit = ANY_SUIT
else:
suit = i
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
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
x += l.XS
for i in range(rows):
s.rows.append(
Gloaming_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS))
x += l.XS
s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self)
# default
l.defaultAll()
def createGame(self, max_rounds=1, num_deal=1):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + (8.5 * l.XS), l.YM +
((2 + len(self.FOUNDATION_SETS)) * l.YS))
# create stacks
x, y = 2 * l.XM, l.YM
w1, w2 = (10 * (l.XS + l.XM)) / self.NUM_RESERVES, 2 * l.XS
if w2 + 13 * l.XOFFSET > w1:
l.XOFFSET = int((w1 - w2) / 13)
for i in range(self.NUM_RESERVES):
stack = OpenStack(x, y, self)
stack.CARD_XOFFSET = l.XOFFSET
l.createText(stack, "sw")
s.reserves.append(stack)
x += (9 / self.NUM_RESERVES) * l.XS
x, y = l.XM, y + l.YS
font = self.app.getFont("canvas_default")
for i in self.FOUNDATION_SETS:
for j in range(4):
stack = AcesAndKings_FoundationStack(x, y, self, suit=j,
base_rank=i[0], dir=1,
max_cards=(13 - i[0]))
if self.preview <= 1:
stack.texts.misc = MfxCanvasText(self.canvas,
x + l.CW // 2,
y + l.CH // 2,
anchor="center",
font=font)
stack.texts.misc.config(text=(RANKS[i[0]][0]))
s.foundations.append(stack)
x = x + l.XS
x = x + (l.XS / 2)
for j in range(4):
stack = AcesAndKings_FoundationStack(x, y, self, suit=j,
base_rank=i[1], dir=-1,
max_cards=(i[1] + 1))
if self.preview <= 1:
stack.texts.misc = MfxCanvasText(self.canvas,
x + l.CW // 2,
y + l.CH // 2,
anchor="center",
font=font)
stack.texts.misc.config(text=(RANKS[i[1]][0]))
s.foundations.append(stack)
x = x + l.XS
x, y = l.XM, y + l.YS
x += (2.5 * l.XM)
s.talon = WasteTalonStack(
x, y, self, max_rounds=max_rounds, num_deal=num_deal)
l.createText(s.talon, "sw")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "se", text_format="%D")
x = ((8.5 - self.NUM_TABLEAU) * l.XS) + l.XM
for i in range(self.NUM_TABLEAU):
s.rows.append(AcesAndKings_RowStack(x, y, self, max_accept=1))
x = x + l.XS
# define stack-groups
l.defaultStackGroups()
