def createGame(self):
rows = 12
l, s = Layout(self), self.s
self.setSize(l.XM + rows * l.XS, l.YM + 3 * l.YS + 16 * l.YOFFSET)
x, y = l.XM + (rows - 8) * l.XS / 2, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += l.XS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1))
x += l.XS
x, y = l.XM + l.XS / 2, l.YM + l.YS
for i in range(rows / 2):
s.reserves.append(BusyCards_FreeCell(x, y, self))
x += 2 * l.XS
x, y = l.XM, l.YM + 2 * l.YS
for i in range(rows):
s.rows.append(UD_SS_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=20, rows=8, reserves=1):
decks = self.gameinfo.decks
l, s = Layout(self), self.s
self.setSize(
l.XM + (reserves + 0.5 + rows) * l.XS,
l.YM + max(2 * l.YS + 7 * l.YOFFSET, l.YS + playcards * l.YOFFSET))
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
x, y = l.XM, l.YM
for i in range(reserves):
stack = ReserveStack(x, y, self, max_cards=UNLIMITED_CARDS)
stack.CARD_YOFFSET = l.YOFFSET
s.reserves.append(stack)
x += l.XS
x, y = l.XM + (reserves + 0.5 + (rows - decks * 4) / 2.0) * l.XS, l.YM
for i in range(4):
s.foundations.append(RK_FoundationStack(x, y, self, suit=ANY_SUIT))
x += l.XS
x, y = l.XM + (reserves + 0.5) * l.XS, l.YM + l.YS
for i in range(rows):
s.rows.append(BasicRowStack(x, y, self, base_rank=NO_RANK))
x += l.XS
l.defaultStackGroups()
def createGame(self):
layout, s = Layout(self), self.s
w0 = layout.XS+5*layout.XOFFSET
self.setSize(layout.XM+5*w0, layout.YM+5*layout.YS)
x, y = layout.XM, layout.YM
for i in range(3):
s.reserves.append(TripleAlliance_Reserve(x, y, self))
x += layout.XS
x, y = self.width-layout.XS, layout.YM
s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
max_move=0, max_accept=0, max_cards=52))
layout.createText(s.foundations[0], 'nw')
y = layout.YM+layout.YS
nstacks = 0
for i in range(4):
x = layout.XM
for j in range(5):
stack = BasicRowStack(x, y, self, max_accept=0)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = layout.XOFFSET, 0
x += w0
nstacks += 1
if nstacks >= 18:
break
y += layout.YS
x, y = self.width-layout.XS, self.height-layout.YS
s.talon = InitialDealTalonStack(x, y, self)
layout.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 7 * l.XS, l.YM + 2 * l.YS + 12 * l.YOFFSET)
x, y = l.XM, l.YM
for i in range(2):
s.reserves.append(OpenStack(x, y, self))
x += l.XS
x, y = l.XM + 3 * l.XS, l.YM
for i in range(4):
s.foundations.append(
DieRussische_Foundation(x, y, self, suit=i, max_cards=8))
x += l.XS
x, y = l.XM + l.XS // 2, l.YM + l.YS
for i in range(6):
s.rows.append(
Thirty_RowStack(x,
y,
self,
max_move=UNLIMITED_MOVES,
max_accept=UNLIMITED_ACCEPTS))
x += l.XS
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.defaultAll()
def createGame(self):
reserves = 8
rows = 10
max_rows = max(8, rows, reserves)
l, s = Layout(self), self.s
self.setSize(l.XM + max_rows * l.XS, l.YM + 4 * l.YS + 12 * l.YOFFSET)
s.addattr(reserves2=[]) # register extra stack variables
x, y = l.XM + (max_rows - reserves) * l.XS // 2 + l.XS // 2, l.YM
for i in range(reserves // 2):
stack = Barrier_ReserveStack(x, y, self)
s.reserves2.append(stack)
l.createText(stack, "ne")
x += 2 * l.XS
x, y = l.XM + (max_rows - reserves) * l.XS // 2, l.YM + l.YS
for i in range(reserves):
s.reserves.append(OpenStack(x, y, self))
x += l.XS
x, y = l.XM + (max_rows - 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 + (max_rows - 8) * l.XS // 2, self.height - l.YS
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i // 2))
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
# Set window size
h = max(5 * l.YS, 20 * l.YOFFSET)
self.setSize(l.XM + 9 * l.XS, l.YM + l.YS + h)
# Create foundations
x = self.width - l.XS
y = l.YM
s.foundations.append(SS_FoundationStack(x, y, self, 4, max_cards=22))
y = y + l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, i, max_cards=14))
y = y + l.YS
# Create rows
x = l.XM
y = l.YM
for j in range(2):
for i in range(8):
s.rows.append(Excuse_RowStack(x, y, self,
max_move=1, max_accept=1, base_rank=NO_RANK))
x = x + l.XS
x = l.XM
y = y + l.YS * 3
self.setRegion(s.rows, (-999, -999, l.XM + l.XS * 8, 999999))
# Create talon
s.talon = InitialDealTalonStack(l.XM, self.height-l.YS, self)
# Define stack groups
l.defaultStackGroups()
def createGame(self, rows=7, reserves=7):
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 16 cards are playable without
# overlap in default window size)
h = max(3*l.YS, l.YS+(16-1)*l.YOFFSET)
maxrows = max(rows, reserves)
self.setSize(l.XM + (maxrows+1)*l.XS, l.YM + h + l.YS)
# extra settings
self.base_card = None
# create stacks
x, y = self.width - l.XS, l.YM
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, suit=i))
y = y + l.YS
self.setRegion(s.foundations, (x - l.CW//2, -999, 999999, 999999))
x, y = l.XM + (maxrows-rows)*l.XS//2, l.YM
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
x, y = l.XM + (maxrows-reserves)*l.XS//2, self.height - l.YS
for i in range(reserves):
s.reserves.append(self.ReserveStack_Class(x, y, self))
x = x + l.XS
self.setRegion(s.reserves, (-999, y - l.CH // 2, 999999, 999999))
s.talon = InitialDealTalonStack(l.XM+1, y, self)
# 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, rows=6, playcards=18):
# create layout
layout, s = Layout(self), self.s
# set window
self.setSize(
layout.XM + rows*layout.XS,
layout.YM + 2*layout.YS + playcards*layout.XOFFSET)
# create stacks
x, y, = layout.XM, layout.YM+layout.YS
for i in range(rows):
s.rows.append(UD_RK_RowStack(x, y, self, mod=13))
x += layout.XS
x, y = layout.XM + (rows-1)*layout.XS//2, layout.YM
stack = BlackHole_Foundation(x, y, self, max_move=0, suit=ANY_SUIT,
base_rank=ANY_RANK, dir=0, mod=13,
max_cards=52*self.gameinfo.decks)
s.foundations.append(stack)
layout.createText(stack, 'ne')
x, y = layout.XM, self.height-layout.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 10.5 * l.XS, l.YM + 2 * l.YS + 20 * l.YOFFSET)
# create stacks
x, y = l.XM, l.YM + l.YS // 2
for i in (0, 1):
stack = ReserveStack(x, y, self, max_cards=4)
s.reserves.append(stack)
stack.CARD_YOFFSET = l.YOFFSET
l.createText(stack, 'n')
x += l.XS
x, y = l.XM + 2.5 * l.XS, l.YM
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i // 2))
x += l.XS
x, y = l.XM + 2.5 * l.XS, l.YM + l.YS
for i in range(8):
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)
# 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 + (
14 + 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 + 14 * l.YOFFSET
for i in range(reserves):
stack = self.Reserve_Class(x, y, self)
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, rows=8, reserves=6):
l, s = Layout(self), self.s
w, h = l.XM + (rows + reserves +
1) * l.XS, l.YM + 3 * l.YS + 16 * l.YOFFSET
self.setSize(w, h)
x, y = l.XM + (rows + reserves + 1 - 8) * l.XS // 2, l.YM
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4))
x += l.XS
x, y = l.XM, l.YM + l.YS
for i in range(reserves):
stack = Headquarters_Reserve(x,
y,
self,
max_cards=UNLIMITED_CARDS,
max_accept=UNLIMITED_CARDS,
max_move=UNLIMITED_CARDS)
s.reserves.append(stack)
stack.CARD_YOFFSET = l.YOFFSET
x += l.XS
x, y = l.XM + (reserves + 1) * l.XS, l.YM + l.YS
for j in range(rows):
s.rows.append(AC_RowStack(x, y, self, base_rank=NO_RANK))
x += l.XS
x, y = w - l.XS, h - l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
self.setSize(l.XM + 8 * l.XS, l.YM + 2 * l.YS + 12 * l.YOFFSET)
# create stacks
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
x, y = l.XM + l.XS, l.YM
for i in range(2):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x += 2 * l.XS
for i in range(2):
s.foundations.append(
AC_FoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_cards=26,
mod=13,
max_move=0))
x += l.XS
x, y = l.XM, l.YM + l.YS
for i in range(8):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
# default
l.defaultAll()
def createGame(self, rows=8, playcards=16):
# create layout
l, s = Layout(self), self.s
# set window
decks = self.gameinfo.decks
max_rows = max(8, rows)
self.setSize(l.XM + max_rows * l.XS,
l.YM + 2 * l.YS + (playcards + 4 * decks) * l.YOFFSET)
# create stacks
x, y = l.XM + (max_rows - 8) * l.XS / 2, l.YM
for i in range(8):
stack = Choice_Foundation(x,
y,
self,
base_rank=(i + 5),
dir=0,
suit=ANY_SUIT,
max_cards=(4 * decks))
stack.CARD_YOFFSET = l.YOFFSET
s.foundations.append(stack)
x += l.XS
x, y = l.XM + (max_rows -
rows) * l.XS / 2, l.YM + l.YS + (4 * decks) * l.YOFFSET
for i in range(rows):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
x, y = self.width - l.XS, 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 + 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, playcards=5):
# create layout
layout, s = Layout(self), self.s
# set window
w = max(2*layout.XS, layout.XS+(playcards-1)*layout.XOFFSET)
self.setSize(layout.XM + 5*w, layout.YM + 4*layout.YS)
# create stacks
y = layout.YM
for i in range(5):
x = layout.XM + i*w
s.rows.append(self.RowStack_Class(x, y, self))
for i in range(2):
y = y + layout.YS
for j in (0, 1, 3, 4):
x = layout.XM + j*w
s.rows.append(self.RowStack_Class(x, y, self))
y = y + layout.YS
for i in range(4):
x = layout.XM + i*w
s.rows.append(self.RowStack_Class(x, y, self))
for r in s.rows:
r.CARD_XOFFSET = layout.XOFFSET
r.CARD_YOFFSET = 0
x, y = layout.XM + 2*w, layout.YM + 3*layout.YS//2
s.foundations.append(BlackHole_Foundation(x, y, self, suit=ANY_SUIT,
dir=0, mod=13, max_move=0, max_cards=52))
layout.createText(s.foundations[0], "s")
x, y = layout.XM + 4*w, self.height - layout.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM + max(9 * l.XS, 5 * l.XS +
18 * l.XOFFSET), l.YM + 2 * l.YS + 12 * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
stack = self.ReserveStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.reserves.append(stack)
self.setRegion(
s.reserves,
(-999, -999, w - 4 * l.XS - l.CW / 2, l.YM + l.YS - l.CH / 2))
x = w - 4 * l.XS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += l.XS
x, y = l.XM + (w - (l.XM + 9 * l.XS)) / 2, l.YM + l.YS
for i in range(9):
s.rows.append(AC_RowStack(x, y, self, max_move=1))
x += l.XS
s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
layout, s = Layout(self), self.s
# set window
h = layout.YS + 6*layout.YOFFSET
self.setSize(layout.XM + 7*layout.XS, layout.YM + 2*h)
# create stacks
y = layout.YM
for i in range(7):
x = layout.XM + i*layout.XS
s.rows.append(
UD_RK_RowStack(x, y, self, mod=13, base_rank=NO_RANK))
y = layout.YM+h
for i in range(6):
x = layout.XM + i*layout.XS
s.rows.append(
UD_RK_RowStack(x, y, self, mod=13, base_rank=NO_RANK))
stack = FourLeafClovers_Foundation(
layout.XM+6*layout.XS, self.height-layout.YS, self,
suit=ANY_SUIT, dir=0, mod=13,
max_move=0, max_cards=52)
s.foundations.append(stack)
layout.createText(stack, 'n')
x, y = layout.XM + 7*layout.XS, self.height - layout.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 20 cards are playable in default window size)
h = max(3*l.YS, 20*l.YOFFSET)
self.setSize(l.XM + 10*l.XS, l.YM + l.YS + h)
# create stacks
x, y = l.XM, l.YM
for i in range(4):
s.reserves.append(ReserveStack(x + (i+3)*l.XS, y, self))
for suit in range(4):
i = (9, 0, 1, 8)[suit]
s.foundations.append(SS_FoundationStack(x + i*l.XS, y, self, suit))
x, y = l.XM, l.YM + l.YS
for i in range(10):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
self.setRegion(s.rows, (-999, y - l.CH // 2, 999999, 999999))
s.talon = InitialDealTalonStack(l.XM, self.height-l.YS, self)
# define stack-groups
self.sg.openstacks = s.foundations + s.rows + s.reserves
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows + s.reserves
self.sg.reservestacks = s.reserves
def createGame(self):
# create layout
layout, s = Layout(self), self.s
# set window
h = layout.YM+layout.YS+4*layout.YOFFSET
self.setSize(layout.XM+7*layout.XS, 3*layout.YM+2*h+layout.YS)
# create stacks
x, y = layout.XM, layout.YM
for i in range(7):
s.rows.append(self.RowStack_Class(x, y, self))
x += layout.XS
x, y = layout.XM, layout.YM+h
for i in range(6):
s.rows.append(self.RowStack_Class(x, y, self))
x += layout.XS
for r in s.rows:
r.CARD_XOFFSET, r.CARD_YOFFSET = 0, layout.YOFFSET
x, y = layout.XM, self.height-layout.YS
stack = BlackHole_Foundation(
x, y, self, ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=52,
base_rank=ANY_RANK)
s.foundations.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = (self.width-layout.XS)//51, 0
layout.createText(stack, 'n')
x = self.width-layout.XS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
layout.defaultStackGroups()
def createGame(self, rows=8, reserves=8):
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 16 cards are playable without
# overlap in default window size)
h = max(2*l.YS, l.YS+(16-1)*l.YOFFSET)
maxrows = max(rows, reserves)
self.setSize(l.XM + maxrows*l.XS, l.YM + l.YS + h + l.YS)
# create stacks
x, y = l.XM + (maxrows-4)*l.XS//2, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, i))
x = x + l.XS
x, y = l.XM + (maxrows-rows)*l.XS//2, y + l.YS
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS
x, y = l.XM + (maxrows-reserves)*l.XS//2, self.height - l.YS
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x = x + l.XS
self.setRegion(s.reserves, (-999, y - l.CH // 2, 999999, 999999))
s.talon = InitialDealTalonStack(l.XM, l.YM, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
w, h = l.XM + 9 * l.XS, l.YM + l.YS + 16 * l.YOFFSET
self.setSize(w, h)
x, y = l.XM, l.YM
for i in range(4):
stack = Striptease_Reserve(x,
y,
self,
max_move=1,
min_cards=1,
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(4):
stack = Striptease_RowStack(x, y, self, max_move=0, mod=13)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.rows.append(stack)
x += l.XS
s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self)
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# (set size so that at least 4 cards are fully playable)
# w = max(2*l.XS, l.XS+(self.PLAYCARDS-1)*l.XOFFSET+2*l.XM)
w = l.XS + (self.PLAYCARDS - 1) * l.XOFFSET + 3 * l.XOFFSET
twidth, theight = self.TWIDTH, int((self.NSTACKS - 1) / self.TWIDTH +
1)
self.setSize(l.XM + twidth * w, l.YM + theight * l.YS)
# create stacks
y = l.YM
for i in range(theight):
x = l.XM
for j in range(twidth):
if i * twidth + j >= self.NSTACKS:
break
stack = PileOn_RowStack(x,
y,
self,
dir=0,
max_cards=self.PLAYCARDS)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
x = x + w
y = y + l.YS
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
self.sg.openstacks = s.rows
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows
def createGame(self, reserves=6):
# create layout
l, s = Layout(self), self.s
# set window
w, h = 2 * l.XM + (4 + reserves) * l.XS, l.YM + l.YS + 16 * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
for i in range(4):
s.rows.append(
self.RowStack_Class(x, y, self, max_move=1, max_accept=0))
x += l.XS
x += l.XM
for i in range(reserves):
stack = self.Foundation_Class(x,
y,
self,
suit=ANY_SUIT,
base_rank=ANY_RANK)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.foundations.append(stack)
x += l.XS
s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self)
# default
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+9*l.XS, l.YM+3*l.YS+12*l.YOFFSET)
# create stacks
x, y = l.XM, l.YM
for i in range(4):
s.foundations.append(
Rittenhouse_Foundation(x, y, self, max_move=0))
x += l.XS
x += l.XS
for i in range(4):
s.foundations.append(Rittenhouse_Foundation(x, y, self,
base_rank=KING, dir=-1, max_move=0))
x += l.XS
x, y = l.XM, l.YM+l.YS
for i in range(9):
s.rows.append(UD_RK_RowStack(x, y, self))
x += l.XS
s.talon = InitialDealTalonStack(l.XM, self.height-l.YS, self)
# default
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 10 * l.XS, l.YM + 5 * l.YS)
# create stacks
for i in range(3):
for j in range(10):
x, y, = l.XM + j * l.XS, l.YM + (i + 1) * l.YS
s.rows.append(
SiebenBisAs_RowStack(x, y, self, max_accept=1,
max_cards=1))
for i in range(2):
x, y, = l.XM + (i + 4) * l.XS, l.YM
s.reserves.append(ReserveStack(x, y, self, max_accept=0))
for i in range(4):
x, y, = l.XM + (i + 3) * l.XS, l.YM + 4 * l.YS
s.foundations.append(
SiebenBisAs_Foundation(x,
y,
self,
i,
base_rank=6,
mod=13,
max_move=0,
max_cards=8))
s.talon = InitialDealTalonStack(l.XM, self.height - l.YS, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
# Set window size
self.setSize(l.XM * 3 + l.XS * 9, l.YM + l.YS * 6)
# Create row stacks
x = l.XM
y = l.YM
for i in range(8):
s.rows.append(
Matsukiri_RowStack(x,
y,
self,
yoffset=l.CH // 2,
max_cards=12,
max_accept=12))
x = x + l.XS
self.setRegion(s.rows, (-999, -999, l.XM + (l.XS * 8) + 10, 999999))
# Create foundation
x = x + l.XM * 2
s.foundations.append(MatsuKiri_Foundation(x, y, self, ANY_SUIT))
# Create talon
s.talon = InitialDealTalonStack(self.width - l.XS, self.height - l.YS,
self)
# Define stack groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = 3 * l.XM + 8 * l.XS, l.YM + 2 * l.YS + 15 * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = 2 * l.XM, l.YM + l.YS
for i in range(8):
s.rows.append(self.RowStack_Class(x, y, self))
x += l.XS
y = l.YM
for i in range(4):
x = l.XM + i * l.XS
s.foundations.append(SS_FoundationStack(x, y, self, i, max_move=0))
x += 2 * l.XM + 4 * l.XS
s.foundations.append(
SS_FoundationStack(x,
y,
self,
i,
base_rank=KING,
max_move=0,
dir=-1))
s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self)
# default
l.defaultAll()
def createGame(self):
# create layout
layout, s = Layout(self), self.s
# set window
h1 = layout.YS+5*layout.YOFFSET
self.setSize(layout.XM+7*layout.XS, layout.YM+2*h1+layout.YS)
# create stacks
y = layout.YM
for i in (0, 1):
x = layout.XM
for j in range(5):
stack = Exit_RowStack(x, y, self, base_rank=NO_RANK,
max_move=1, max_accept=1, dir=0)
s.rows.append(stack)
stack.CARD_YOFFSET = layout.YOFFSET
x += layout.XS
y += h1
x, y = self.width-layout.XS, layout.YM
stack = Exit_RowStack(x, y, self, base_rank=NO_RANK,
max_move=1, max_accept=1, dir=0)
s.reserves.append(stack)
stack.CARD_YOFFSET = layout.YOFFSET
x, y = self.width-layout.XS, self.height-layout.YS
s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
max_accept=0, max_move=0, max_cards=52))
layout.createText(s.foundations[0], "n")
x, y = layout.XM, self.height-layout.YS
s.talon = InitialDealTalonStack(x, y, self)
# 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()
