def createGame(self):
l, s = Layout(self), self.s
w0 = l.XS+5*l.XOFFSET
self.setSize(l.XM+5*w0, l.YM+5*l.YS)
x, y = l.XM, l.YM
for i in range(3):
s.reserves.append(TripleAlliance_Reserve(x, y, self))
x += l.XS
x, y = self.width-l.XS, l.YM
s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
max_move=0, max_accept=0, max_cards=52))
l.createText(s.foundations[0], 'nw')
y = l.YM+l.YS
nstacks = 0
for i in range(4):
x = l.XM
for j in range(5):
stack = BasicRowStack(x, y, self, max_accept=0)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
x += w0
nstacks += 1
if nstacks >= 18:
break
y += l.YS
x, y = self.width-l.XS, self.height-l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
xx, yy = 9, 6
w, h = l.XM + xx * l.XS, l.YM + yy * l.YS
self.setSize(w, h)
# create stacks
for i in range(yy):
for j in range(xx):
n = j + xx * i
if n < 1:
continue
if n > 52:
break
k = j
if i % 2:
k = xx - j - 1
x, y = l.XM + k * l.XS, l.YM + i * l.YS
s.rows.append(self.RowStack_Class(x, y, self))
s.talon = PushPin_Talon(l.XM, l.YM, self)
s.foundations.append(
PushPin_Foundation(
l.XM, h - l.YS, self, suit=ANY_SUIT, dir=0, base_rank=ANY_RANK, max_accept=0, max_move=0, max_cards=52
)
)
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w = l.XM + 9*l.XS
h = l.YM + 5.67*l.YS
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
s.rows += self._createPyramid(l, x, y, 2)
x, y = l.XM+2*l.XS, l.YM
s.rows += self._createPyramid(l, x, y, 7)
x, y = l.XM+2.5*l.XS, l.YM+3*l.YS
s.rows += self._createPyramid(l, x, y, 6)
x, y = l.XM, self.height-l.YS
s.talon = self.Talon_Class(x, y, self)
x, y = self.width - l.XS, l.YM
s.foundations.append(Pyramid_Foundation(x, y, self,
suit=ANY_SUIT, dir=0, base_rank=ANY_RANK,
max_move=0, max_cards=52))
l.createText(s.foundations[0], 's')
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+9*l.XS, 3*l.YM+5*l.YS)
# create stacks
x, y = l.XM, l.YM
s.talon = Cone_Talon(x, y, self)
l.createText(s.talon, 's')
y += l.YS+2*l.YM
for i in range(4):
s.reserves.append(OpenStack(x, y, self, max_accept=0))
y += l.YS
x, y = l.XM+l.XS, l.YM
for i in range(7):
s.rows.append(AC_RowStack(x, y, self, mod=13))
x += l.XS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
mod=13, max_cards=26))
y += l.YS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+8*l.XS, l.YM+max(4*l.YS, 3*l.YS+14*l.YOFFSET))
x, y = l.XM, self.height-l.YS
for i in range(4):
suit = i
if self.Foundation_Class_1 is RK_FoundationStack: suit = ANY_SUIT
s.foundations.append(self.Foundation_Class_1(x, y, self, suit=suit))
x += l.XS
for i in range(4):
suit = i
if self.Foundation_Class_1 is RK_FoundationStack: suit = ANY_SUIT
s.foundations.append(self.Foundation_Class_2(x, y, self, suit=suit))
x += l.XS
x, y = l.XM+2*l.XS, l.YM+l.YS
for i in range(4):
s.rows.append(LadyOfTheManor_RowStack(x, y, self, max_accept=0))
x += l.XS
for i, j in ((0,2), (0,1), (0,0),
(1,0), (2,0), (3,0), (4,0), (5,0), (6,0),
(7,0), (7,1), (7,2),):
x, y = l.XM+i*l.XS, l.YM+j*l.YS
s.reserves.append(LadyOfTheManor_Reserve(x, y, self, max_accept=0))
s.talon = InitialDealTalonStack(self.width-l.XS, self.height-2*l.YS, self)
l.defaultAll()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+9.5*l.XS, l.YM+4*l.YS)
x, y = l.XM+l.XS, l.YM
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i%4,
base_rank=JACK, dir=-1, max_cards=11))
x += l.XS
x, y = l.XM+l.XS, l.YM+l.YS
for i in range(8):
s.foundations.append(Adela_Foundation(x, y, self, suit=i%4,
base_rank=QUEEN, max_cards=1))
x += l.XS
x, y = l.XM+l.XS, l.YM+2*l.YS
for i in range(8):
s.foundations.append(Adela_Foundation(x, y, self, suit=i%4,
base_rank=KING, max_cards=1))
x += l.XS
x, y = l.XM, l.YM+l.YS
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, 'n')
x, y = l.XM+l.XS/2, l.YM+3*l.YS
for i in range(9):
stack = SS_RowStack(x, y, self, max_move=1, dir=1)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x += l.XS
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+9*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))
y += l.YS
x, y = self.width-l.XS, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self,
suit=i, base_rank=KING, dir=-1))
y += l.YS
x, y = (self.width-l.XS)/2, self.height-l.YS
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, 'se')
y = l.YM
for i in range(4):
x = l.XM+l.XS*3/2
for j in range(6):
stack = UD_SS_RowStack(x, y, self, base_rank=NO_RANK)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
x += l.XS
y += l.YS
l.defaultStackGroups()
def createGame(self, rows=13, reserves=10, playcards=20):
# create layout
l, s = Layout(self), self.s
# set window
decks = self.gameinfo.decks
max_rows = max(decks*4, rows, reserves)
w, h = l.XM+max_rows*l.XS, l.YM+3*l.YS+playcards*l.YOFFSET
self.setSize(w, h)
# create stacks
s.talon = self.Talon_Class(l.XM, h-l.YS, self)
x, y = l.XM+(max_rows-decks*4)*l.XS//2, l.YM
for j in range(4):
for i in range(decks):
s.foundations.append(self.Foundation_Class(x, y, self, suit=j))
x += l.XS
x, y = l.XM+(max_rows-reserves)*l.XS//2, l.YM+l.YS
for i in range(reserves):
s.reserves.append(ReserveStack(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(self.RowStack_Class(x, y, self))
x += l.XS
# default
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = 3*l.XM+10*l.XS, 2*l.YM+2*l.YS+16*l.YOFFSET
self.setSize(w, h)
# create stacks
s.talon = self.Talon_Class(l.XM, h-l.YS, self)
x, y = 3*l.XM + 6*l.XS, l.YM
for i in range(4):
s.foundations.append(
self.Foundation_Class(
x, y, self, suit=i, mod=13, max_cards=26))
x += l.XS
x, y = 2*l.XM, l.YM + l.YS + l.YM
for i in range(10):
s.rows.append(self.RowStack_Class(x, y, self))
x += l.XS
x, y = l.XM, l.YM
for i in range(6):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
# default
l.defaultAll()
def createGame(self, max_rounds=1, num_deal=1, **layout):
l, s = Layout(self), self.s
kwdefault(layout, rows=8, waste=1)
self.Layout_Method(l, **layout)
self.setSize(l.size[0], l.size[1])
# Create talon
s.talon = self.Talon_Class(
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)
# Create foundations
for r in l.s.foundations:
s.foundations.append(
self.Foundation_Class(
r.x, r.y, self,
r.suit, mod=12, max_cards=12, max_move=self.MAX_MOVE))
# Create row stacks
for r in l.s.rows:
s.rows.append(
self.RowStack_Class(
r.x, r.y, self,
suit=ANY_SUIT, base_rank=self.BASE_RANK))
# Define stack groups
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM+12*l.XS, l.YM+2*l.YS+2*(l.YS+5*l.YOFFSET)
self.setSize(w, h)
# create stacks
y = l.YM+2*l.YS
for i in range(2):
x = l.XM
for j in range(12):
s.rows.append(BasicRowStack(x, y, self, max_accept=0))
x += l.XS
y += l.YS+5*l.YOFFSET
x = l.XM+2*l.XS
for j in range(2):
for i in range(4):
y = l.YM
s.foundations.append(
SS_FoundationStack(x, y, self, suit=j*2+i//2))
y += l.YS
s.foundations.append(SS_FoundationStack(x, y, self,
suit=j*2+i//2, base_rank=KING, dir=-1))
x += l.XS
s.reserves.append(ReserveStack(l.XM, l.YM, self))
s.reserves.append(ReserveStack(w-l.XS, l.YM, self))
s.talon = InitialDealTalonStack(l.XM, l.YM+l.YS, 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
# set window
self.setSize(l.XM+8*l.XS, l.YM+5*l.YS)
# create stacks
x, y = l.XM, l.YM
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self,
suit=i/2, max_cards=10))
x += l.XS
y = l.YM+l.YS
for i in range(3):
x = l.XM
for j in range(8):
##stack = SS_RowStack(x, y, self, max_move=1)
stack = ReserveStack(x, y, self)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x += l.XS
y += l.YS
x, y = self.width-l.XS, self.height-l.YS
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, 'sw')
# define stack-groups
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+16*l.YOFFSET)
# create stacks
x, y = l.XM, l.YM
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, "s")
x += 2*l.XS
s.reserves.append(ReserveStack(x, y, self))
x += 2*l.XS
for i in range(4):
s.foundations.append(Spider_SS_Foundation(x, y, self,
suit=ANY_SUIT))
x += l.XS
x, y = l.XM+l.XS, l.YM+l.YS
for i in range(7):
s.rows.append(Spider_RowStack(x, y, self,
base_rank=ANY_RANK))
x += l.XS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
h1 = l.YS+5*l.YOFFSET
self.setSize(l.XM+7*l.XS, l.YM+2*h1+l.YS)
# create stacks
y = l.YM
for i in (0, 1):
x = l.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 = l.YOFFSET
x += l.XS
y += h1
x, y = self.width-l.XS, l.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 = l.YOFFSET
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")
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
# 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(RK_RowStack(x, y, self, base_rank=11,
max_move=12, max_cards=99))
x = x + l.XS
# Create reserve stacks
x = self.width - l.XS
y = l.YM
for i in range(6):
s.reserves.append(ReserveStack(x, y, self))
y = y + l.YS
y = y - l.YS
for i in range(4):
x = x - l.XS
s.reserves.append(ReserveStack(x, y, self))
self.setRegion(s.rows, (0, 0, l.XM + l.XS * 8, l.YS * 5))
# Create talon
s.talon = DealRowTalonStack(l.XM, self.height - l.YS, self)
l.createText(s.talon, "n")
# Define stack groups
l.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, rows=8, reserves=1):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + (1+max(8,rows))*l.XS, l.YM + (1+max(4, reserves))*l.YS+l.TEXT_HEIGHT)
# create stacks
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
for i in range(8):
x = x + l.XS
s.foundations.append(self.Foundation_Class(x, y, self, suit=i/2))
x, y = l.XM, y + l.YS
rx, ry = x + l.XS - l.CW/2, y - l.CH/2
for i in range(reserves):
s.reserves.append(self.ReserveStack_Class(x, y+l.TEXT_HEIGHT, self))
y = y + l.YS
l.createText(s.talon, "s")
if s.reserves:
self.setRegion(s.reserves, (-999, ry+l.TEXT_HEIGHT, rx-1, 999999))
else:
rx = -999
x, y = l.XM + (8-rows)*l.XS/2, l.YM + l.YS
for i in range(rows):
x = x + l.XS
s.rows.append(self.RowStack_Class(x, y, self))
self.setRegion(s.rows, (rx, ry, 999999, 999999))
# define stack-groups
l.defaultStackGroups()
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
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, 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):
# create layout
l, s = Layout(self), self.s
# set window
# (set size so that at least 7 cards are fully playable)
dx = l.XM+l.XS+7*l.XOFFSET
w = l.XM+max(5*dx, 9*l.XS+2*l.XM)
h = l.YM+6*l.YS
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
s.talon = TalonStack(x, y, self)
l.createText(s.talon, "se")
x = max(l.XS+3*l.XM, (self.width-l.XM-8*l.XS)//2)
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
y = l.YM+l.YS
for i in range(5):
x = l.XM
for j in range(5):
stack = UD_SS_RowStack(x, y, self)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
x += dx
y += l.YS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(7*l.XS+l.XM, 5*l.YS+l.YM)
# create stacks
for i in range(7):
x = l.XM + (6-i) * l.XS // 2
y = l.YM + l.YS + i * l.YS // 2
for j in range(i+1):
s.rows.append(Pyramid_RowStack(x, y, self))
x = x + l.XS
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = Pyramid_Waste(x, y, self, max_accept=1)
l.createText(s.waste, "s")
s.waste.CARD_XOFFSET = 14
x, y = self.width - l.XS, l.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), 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):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM+(8+2)*l.XS, l.YM+max(3*(l.YS+8*l.YOFFSET), 8*l.YS)
self.setSize(w, h)
# create stacks
y = l.YM
for i in range(3):
x = l.XM
for j in range(8):
s.rows.append(UD_SS_RowStack(x, y, self, base_rank=NO_RANK))
x += l.XS
y += l.YS+8*l.YOFFSET
y = l.YM
for j in range(2):
for i in range(4):
x = l.XM+8*l.XS
s.foundations.append(SS_FoundationStack(x, y, self,
suit=j*2+i//2, max_move=0))
x += l.XS
s.foundations.append(
SS_FoundationStack(
x, y, self,
suit=j*2+i//2, base_rank=KING, max_move=0, dir=-1))
y += l.YS
s.talon = InitialDealTalonStack(l.XM, h-l.YS, self)
# default
l.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+13*l.XS, l.YM+3*l.YS+12*l.YOFFSET)
# create stacks
y = l.YM
for i in range(2):
x = l.XM+2*l.XS
for j in range(8):
s.foundations.append(Spider_SS_Foundation(x, y, self,
dir=-2, base_rank=ANY_RANK,
min_accept=6, max_cards=6, max_move=0))
x += l.XS
s.foundations.append(TheJollyRoger_Foundation(x, y, self,
suit=ANY_SUIT, dir=0,
min_accept=4, max_accept=4,
max_cards=4, max_move=0))
y += l.YS
x, y = l.XM, l.YM+2*l.YS
for i in range(13):
s.rows.append(TheJollyRoger_RowStack(x, y, self, dir=2,
max_move=UNLIMITED_MOVES, max_accept=UNLIMITED_ACCEPTS))
x += l.XS
s.talon = DealRowTalonStack(l.XM, l.YM, self)
l.createText(s.talon, 's')
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = 2*l.XM+8*l.XS, max(2*(l.YM+l.YS+8*l.YOFFSET), l.YM+5*l.YS)
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
for i in range(6):
s.rows.append(UD_SS_RowStack(x, y, self, base_rank=NO_RANK))
x += l.XS
x, y = l.XM, l.YM+l.YS+8*l.YOFFSET
for i in range(6):
s.rows.append(UD_SS_RowStack(x, y, self, base_rank=NO_RANK))
x += l.XS
y = l.YM
for i in range(4):
x = l.XM+6*l.XS+l.XM
s.foundations.append(SS_FoundationStack(x, y, self, i, max_move=0))
x += l.XS
s.foundations.append(SS_FoundationStack(x, y, self, i,
base_rank=KING, max_move=0, dir=-1))
y += l.YS
s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self)
# default
l.defaultAll()
def createGame(self, **layout):
l, s = Layout(self), self.s
kwdefault(layout, rows=14, reserves=4, texts=0)
self.Layout_Method(l, **layout)
self.setSize(l.size[0], l.size[1])
# Create foundations
for r in l.s.foundations:
s.foundations.append(
self.Foundation_Class(
r.x, r.y, self,
r.suit, mod=12, max_cards=12))
# Create reserve stacks
for r in l.s.reserves:
s.reserves.append(ReserveStack(r.x, r.y, self, ))
# Create row stacks
for r in l.s.rows:
s.rows.append(
self.RowStack_Class(
r.x, r.y, self, max_cards=12,
suit=ANY_SUIT, base_rank=self.BASE_RANK))
# Create talon
s.talon = self.Talon_Class(l.s.talon.x, l.s.talon.y, self)
# Define stack groups
l.defaultAll()
def createGame(self, rows=8, reserves=1):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+11*l.XS, l.YM+2*l.YS+12*l.YOFFSET+20)
# create stacks
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, 's')
x += l.XS
stack = Surprise_ReserveStack(x, y, self, max_cards=3)
xoffset = min(l.XOFFSET, l.XS/3)
stack.CARD_XOFFSET = xoffset
s.reserves.append(stack)
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+l.TEXT_HEIGHT
for i in range(11):
s.rows.append(KingAC_RowStack(x, y, self))
x += l.XS
# 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 + 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), self.s
# set window
# (piles up to 9 cards are fully playable in default window size)
dh = max(3*l.YS/2+l.CH, l.YS+(9-1)*l.YOFFSET)
self.setSize(10*l.XS+l.XM, l.YM+2*dh)
# create stacks
for i in range(2):
x, y = l.XM, l.YM + i*dh
for j in range(4):
s.rows.append(RK_RowStack(x, y, self, max_move=1, max_accept=1))
x = x + l.XS
y = l.YM + dh - l.CH / 2
self.setRegion(s.rows[:4], (-999, -999, x - l.XM / 2, y))
self.setRegion(s.rows[4:], (-999, y, x - l.XM / 2, 999999))
d = [ (0,0), (1,0.15), (2,0.5), (2.5,1.5), (2,2.5), (1,2.85) ]
for i in range(len(d)):
d.append( (0 - d[i][0], 3 - d[i][1]) )
x0, y0 = l.XM, l.YM + dh - l.CH
for i in range(12):
j = (i + 5) % 12
x = int(round(x0 + ( 6.5+d[j][0]) * l.XS))
y = int(round(y0 + (-1.5+d[j][1]) * l.YS))
suit = (1, 2, 0, 3) [i % 4]
s.foundations.append(SS_FoundationStack(x, y, self, suit,
base_rank=i+1, mod=13,
max_move=0))
s.talon = InitialDealTalonStack(self.width-l.XS, self.height-l.YS, self)
# define stack-groups
self.sg.openstacks = s.foundations + s.rows
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+6*l.XS, l.YM+2*l.YS+12*l.YOFFSET)
x, y, = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, "s")
x, y = l.XM+2*l.XS, l.YM
for i in range(4):
s.foundations.append(Formic_Foundation(x, y, self,
suit=ANY_SUIT, base_rank=ANY_RANK,
max_cards=52, max_move=0))
x += l.XS
x, y = l.XM+2*l.XS, l.YM+l.YS
for i in range(4):
s.rows.append(BasicRowStack(x, y, self, max_move=1, max_accept=0))
x += l.XS
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
h = l.YS + 7 * l.YOFFSET
self.setSize(l.XM + 10 * l.XS, l.YM + l.YS + 2 * h)
# create stacks
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
x, y = l.XM + l.XS, l.YM
for i in range(8):
s.rows.append(
SS_RowStack(x, y, self, dir=1, max_move=1, max_accept=1))
x += l.XS
x, y = l.XM + l.XS, l.YM + l.YS + h
for i in range(8):
s.rows.append(
SS_RowStack(x, y, self, dir=-1, max_move=1, max_accept=1))
x += l.XS
x, y = l.XM + l.XS, l.YM + h
for i in range(8):
stack = HeadsAndTails_Reserve(x, y, self)
s.reserves.append(stack)
l.createText(stack, "n")
x += l.XS
x, y = l.XM, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
y += l.YS
x, y = l.XM + 9 * l.XS, l.YM
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1))
y += l.YS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
n = m = max(self.ROWS)
if self.ROWS[0] == m or self.ROWS[-1] == m:
n = n + 1
self.setSize(l.XM + n*l.XS, l.YM + len(self.ROWS)*l.YS)
# game extras 1)
self.map = {}
# create stacks
for i in range(len(self.ROWS)):
r = self.ROWS[i]
for j in range(r):
d = m - r + 2*j
x, y = l.XM + d*l.XS//2, l.YM + i*l.YS
stack = Pegged_RowStack(x, y, self)
stack.pos = (d, 2*i)
# print stack.id, stack.pos
s.rows.append(stack)
self.map[stack.pos] = stack
x, y = self.width - l.XS, l.YM
s.foundations.append(
AbstractFoundationStack(
x, y, self, ANY_SUIT, max_move=0, max_accept=0,
max_cards=self.gameinfo.ncards))
l.createText(s.foundations[0], "s")
y = self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
s.internals.append(InvisibleStack(self))
# game extras 2)
self.STEP_MAP = {}
for step in self.STEPS:
self.STEP_MAP[step] = 1
if self.EMPTY_STACK_ID < 0:
self.EMPTY_STACK_ID = len(s.rows) // 2
# Define stack groups
l.defaultStackGroups()
def createGame(self):
rows = 8
layout, s = Layout(self), self.s
self.setSize(
layout.XM+rows*layout.XS, layout.YM+2*layout.YS+20*layout.YOFFSET)
x, y = layout.XM, layout.YM
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self))
x += layout.XS
x, y = layout.XM+(rows-1)*layout.XS//2, self.height-layout.YS
s.foundations.append(Waterfall_Foundation(x, y, self, suit=ANY_SUIT,
max_cards=104))
stack = s.foundations[0]
tx, ty, ta, tf = layout.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-layout.XS, self.height-layout.YS
s.talon = DealRowTalonStack(x, y, self)
layout.createText(s.talon, 'sw')
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# game extras
self.other_stack = None
self.closed_cards = -1
self.score = 0
# create text
x, y = l.XM, self.ROWS * l.YS
if self.preview <= 1:
self.texts.score = MfxCanvasText(
self.canvas,
x,
y,
anchor="sw",
font=self.app.getFont("canvas_large"))
x = self.texts.score.bbox()[1][0] + 16
# set window
w = max(2 * l.XS, x)
self.setSize(l.XM + w + self.COLUMNS * l.XS, l.YM + self.ROWS * l.YS)
# create stacks
for i in range(self.ROWS):
for j in range(self.COLUMNS):
x, y = l.XM + w + j * l.XS, l.YM + i * l.YS
s.rows.append(
Memory_RowStack(x,
y,
self,
max_move=0,
max_accept=0,
max_cards=1))
x, y = l.XM, l.YM
s.talon = InitialDealTalonStack(x, y, self)
l.createText(s.talon, anchor="n", text_format="%D")
s.internals.append(InvisibleStack(self))
# define stack-groups
l.defaultStackGroups()
def createGame(self, **layout):
# create layout
l, s = Layout(self), self.s
l.freeCellLayout(rows=4, reserves=4, texts=1)
self.setSize(l.size[0], l.size[1])
# create stacks
s.talon = Strategerie_Talon(l.s.talon.x, l.s.talon.y, self)
for r in l.s.foundations:
s.foundations.append(RK_FoundationStack(r.x, r.y, self))
for r in l.s.rows:
s.rows.append(
Strategerie_RowStack(r.x,
r.y,
self,
max_accept=UNLIMITED_ACCEPTS))
for r in l.s.reserves:
s.reserves.append(Strategerie_ReserveStack(r.x, r.y, self))
# default
l.defaultAll()
self.sg.dropstacks.append(s.talon)
def createGame(self, rows=10, playcards=20):
l, s = Layout(self), self.s
self.setSize(l.XM + max(rows, 8) * l.XS,
l.YM + 2 * l.YS + playcards * l.YOFFSET)
x, y = l.XM, l.YM
stack = OpenStack(x, y, self, max_move=1, max_accept=0)
s.reserves.append(stack)
l.createText(stack, 'ne')
x, y = self.width - 8 * 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 = self.width - rows * l.XS, l.YM + l.YS
for i in range(rows):
s.rows.append(Yukon_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=9, reserves=8):
# create layout
l, s = Layout(self), self.s
# set size
self.setSize(l.XM + 10 * l.XS,
l.YM + (5 + len(self.Foundation_Classes)) * l.YS)
#
playcards = 4 * l.YS // l.YOFFSET
xoffset, yoffset = [], []
for i in range(playcards):
xoffset.append(0)
yoffset.append(l.YOFFSET)
for i in range(104 - playcards):
xoffset.append(l.XOFFSET)
yoffset.append(0)
# create stacks
y = l.YM
for found_class in self.Foundation_Classes:
x = l.XM
for i in range(8):
s.foundations.append(
found_class(x, y, self, suit=ANY_SUIT, max_move=0))
x += l.XS
y += l.YS
x, y = l.XM, l.YM + l.YS * len(self.Foundation_Classes)
self.setRegion(s.foundations, (-999, -999, 999999, y - l.XM // 2))
for i in range(8):
stack = self.RowStack_Class(x, y, self, max_move=1)
stack.CARD_XOFFSET = xoffset
stack.CARD_YOFFSET = yoffset
s.rows.append(stack)
x += l.XS
s.talon = self.Talon_Class(l.XM + 9 * l.XS, l.YM, self)
l.createText(s.talon, "s")
# define stack-groups
l.defaultStackGroups()
def createGame(self, playcards=5):
# create layout
l, s = Layout(self), self.s
# set window
w = max(2 * l.XS, l.XS + (playcards - 1) * l.XOFFSET)
self.setSize(l.XM + 5 * w, l.YM + 4 * l.YS)
# create stacks
y = l.YM
for i in range(5):
x = l.XM + i * w
s.rows.append(self.RowStack_Class(x, y, self))
for i in range(2):
y = y + l.YS
for j in (0, 1, 3, 4):
x = l.XM + j * w
s.rows.append(self.RowStack_Class(x, y, self))
y = y + l.YS
for i in range(4):
x = l.XM + i * w
s.rows.append(self.RowStack_Class(x, y, self))
for r in s.rows:
r.CARD_XOFFSET = l.XOFFSET
r.CARD_YOFFSET = 0
x, y = l.XM + 2 * w, l.YM + 3 * l.YS // 2
s.foundations.append(
BlackHole_Foundation(x,
y,
self,
suit=ANY_SUIT,
dir=0,
mod=13,
max_move=0,
max_cards=52))
l.createText(s.foundations[0], "s")
x, y = l.XM + 4 * w, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=3, columns=6):
layout, s = Layout(self), self.s
decks = self.gameinfo.decks
maxrows = max(columns, 2 + decks * 4)
self.setSize(layout.XM + maxrows * layout.XS,
layout.YM + (rows + 1) * layout.YS)
x, y = layout.XM, layout.YM
s.talon = TalonStack(x, y, self)
layout.createText(s.talon, 'ne')
x, y = layout.XM + 2 * layout.XS, layout.YM
for found in self.Foundation_Classes:
if self.SEPARATE_FOUNDATIONS:
for i in range(4):
s.foundations.append(found(x, y, self, suit=i))
x += layout.XS
else:
s.foundations.append(found(x, y, self, suit=ANY_SUIT))
if self.SPREAD_FOUNDATION:
w1, w2 = 6 * layout.XS + layout.XM, 2 * layout.XS
totalcards = self.gameinfo.ncards
if w2 + totalcards * layout.XOFFSET > w1:
layout.XOFFSET = int((w1 - w2) / totalcards)
s.foundations[0].CARD_XOFFSET = layout.XOFFSET
y = layout.YM + layout.YS
for i in range(rows):
x = layout.XM + (maxrows - columns) * layout.XS // 2
for j in range(columns):
s.rows.append(Vague_RowStack(x, y, self))
x += layout.XS
y += layout.YS
layout.defaultStackGroups()
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.XS, l.YM
for i in range(8):
s.foundations.append(
MountOlympus_Foundation(x,
y,
self,
suit=i / 2,
base_rank=ACE,
dir=2,
max_move=0,
max_cards=7))
x += l.XS
x, y = l.XM + l.XS, l.YM + l.YS
for i in range(8):
s.foundations.append(
MountOlympus_Foundation(x,
y,
self,
suit=i / 2,
base_rank=1,
dir=2,
max_move=0,
max_cards=6))
x += l.XS
x, y = l.XM, l.YM + 2 * l.YS
for i in range(9):
s.rows.append(self.RowStack_Class(x, y, self, dir=-2))
x += l.XS
s.talon = DealRowTalonStack(l.XM, l.YM, self)
l.createText(s.talon, 's')
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=12):
l, s = Layout(self), self.s
self.setSize(l.XM+rows*l.XS, l.YM+2*l.YS+l.TEXT_HEIGHT+20*l.YOFFSET)
x, y = l.XM+(rows-4)/2*l.XS, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
mod=13, max_cards=26))
x += l.XS
x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self, mod=13))
x += l.XS
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, num_deal=2, max_rounds=1)
l.createText(s.talon, 's')
x = x + l.XS
s.waste = WasteStack(x, y, self, max_cards=2)
s.waste.CARD_XOFFSET = l.XOFFSET
l.defaultStackGroups()
def createGame(self, **layout):
# create layout
l, s = Layout(self), self.s
kwdefault(layout, rows=8, waste=0, texts=1, playcards=20)
l.klondikeLayout(**layout)
self.setSize(l.size[0], l.size[1])
# create stacks
s.talon = Dumfries_TalonStack(l.s.talon.x, l.s.talon.y, self)
for r in l.s.foundations:
s.foundations.append(
SS_FoundationStack(r.x, r.y, self, suit=r.suit))
for r in l.s.rows:
s.rows.append(
Dumfries_RowStack(r.x,
r.y,
self,
max_move=UNLIMITED_MOVES,
max_accept=UNLIMITED_ACCEPTS))
# default
l.defaultAll()
self.sg.dropstacks.append(s.talon)
def createGame(self, rows=8, reserves=6, playcards=12):
# create layout
l, s = Layout(self), self.s
# set window
decks = self.gameinfo.decks
foundations = decks * 4
max_rows = max(foundations, rows)
w, h = l.XM + (max_rows +
1) * l.XS, l.YM + 3 * l.YS + playcards * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM + l.XS + (max_rows - foundations) * l.XS // 2, l.YM
for fclass in self.Foundation_Classes:
for i in range(4):
s.foundations.append(fclass(x, y, self, suit=i))
x += l.XS
x, y = l.XM + l.XS + (max_rows - rows) * l.XS // 2, l.YM + l.YS
for i in range(rows):
s.rows.append(
self.RowStack_Class(x, y, self, max_move=1, max_accept=1))
x += l.XS
self.setRegion(s.rows,
(-999, y - l.CH // 2, 999999, h - l.YS - l.CH // 2))
d = (w - reserves * l.XS) // reserves
x, y = l.XM, h - l.YS
for i in range(reserves):
stack = ReserveStack(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 2, 0
s.reserves.append(stack)
x += l.XS + d
s.talon = self.Talon_Class(l.XM, l.YM, self)
l.createText(s.talon, "s")
# define stack-groups
l.defaultStackGroups()
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):
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# 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(
RK_RowStack(x,
y,
self,
base_rank=11,
max_move=12,
max_cards=99))
x = x + l.XS
# Create reserve stacks
x = self.width - l.XS
y = l.YM
for i in range(6):
s.reserves.append(ReserveStack(x, y, self))
y = y + l.YS
y = y - l.YS
for i in range(4):
x = x - l.XS
s.reserves.append(ReserveStack(x, y, self))
self.setRegion(s.rows, (0, 0, l.XM + l.XS * 8, l.YS * 5))
# Create talon
s.talon = DealRowTalonStack(l.XM, self.height - l.YS, self)
l.createText(s.talon, "n")
# Define stack groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self, card_x_space=4), self.s
# game extras
self.other_stack = None
self.closed_cards = -1
self.score = 0
# set window
self.setSize(l.XM + self.COLUMNS * l.XS, l.YM + (self.ROWS + 1) * l.YS)
# create stacks
for i in range(self.ROWS):
for j in range(self.COLUMNS):
x, y = l.XM + j * l.XS, l.YM + i * l.YS
s.rows.append(
Concentration_RowStack(x,
y,
self,
max_move=0,
max_accept=0,
max_cards=1))
x, y = l.XM + self.COLUMNS * l.XS / 2, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.createText(s.talon, dx=-10, anchor="sw", text_format="%D")
# create text
x, y = l.XM, self.height - l.YM
if self.preview <= 1:
self.texts.score = MfxCanvasText(
self.canvas,
x,
y,
anchor="sw",
font=self.app.getFont("canvas_large"))
# define stack-groups
l.defaultStackGroups()
def createGame(self, round_text=True):
decks = self.gameinfo.decks
# create layout
l, s = Layout(self, card_x_space=4), self.s
# set window
w, h = l.XM + self.RSTEP * l.XS, l.YM + (4 * decks) * l.YS
if round_text:
h += l.YS
self.setSize(w, h)
# create stacks
for k in range(decks):
for i in range(4):
x, y = l.XM, l.YM + (i + k * 4) * l.YS
for j in range(self.RSTEP):
s.rows.append(
self.RowStack_Class(x,
y,
self,
max_accept=1,
max_cards=1))
x += l.XS
if round_text:
x, y = l.XM + (self.RSTEP - 1) * l.XS // 2, self.height - l.YS
s.talon = self.Talon_Class(x, y, self)
l.createRoundText(s.talon, 'se')
else:
# Talon is invisible
x, y = self.getInvisibleCoords()
s.talon = self.Talon_Class(x, y, self)
if self.RBASE:
# create an invisible stack to hold the four Aces
s.internals.append(InvisibleStack(self))
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 6 * l.XS, 2 * l.YM + 2 * l.YS + 6 * l.YOFFSET)
# create stacks
for i in range(2):
for j in range(4):
x, y = l.XM + j * l.XS, l.YM + i * (l.YM + l.YS +
3 * l.YOFFSET)
s.rows.append(
Nestor_RowStack(x,
y,
self,
max_move=1,
max_accept=1,
dir=0,
base_rank=NO_RANK))
x, y = self.width - l.XS, l.YM
s.talon = InitialDealTalonStack(x, y, self)
x, y = self.width - l.XS, self.height - l.YS
s.foundations.append(
AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_move=0,
max_cards=32,
max_accept=0,
base_rank=ANY_RANK))
l.createText(s.foundations[0], "n")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+10*l.XS, l.YM+4*l.YS+l.TEXT_HEIGHT)
# create stacks
x, y, = l.XS, l.YM
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self,
suit=i, max_move=0))
x += l.XS
x += 2*l.XM
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self,
suit=i, max_move=0, base_rank=KING, dir=-1))
x += l.XS
y = l.YM+l.YS
for i in range(2):
x = l.XM
for j in range(10):
stack = self.RowStack_Class(x, y, self,
max_move=1, max_accept=1)
s.rows.append(stack)
stack.CARD_XOFFSET = stack.CARD_YOFFSET = 0
x += l.XS
y += l.YS
x, y = l.XM + 9*l.XS, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "n")
x -= l.XS
s.waste = WasteStack(x, y, self, max_cards=1)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
w0 = l.XS + 5 * l.XOFFSET
self.setSize(l.XM + 5 * w0, l.YM + 5 * l.YS)
x, y = l.XM, l.YM
for i in range(3):
s.reserves.append(TripleAlliance_Reserve(x, y, self))
x += l.XS
x, y = self.width - l.XS, l.YM
s.foundations.append(
AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_move=0,
max_accept=0,
max_cards=52))
l.createText(s.foundations[0], 'nw')
y = l.YM + l.YS
nstacks = 0
for i in range(4):
x = l.XM
for j in range(5):
stack = BasicRowStack(x, y, self, max_accept=0)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
x += w0
nstacks += 1
if nstacks >= 18:
break
y += l.YS
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
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):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 7*l.XS, l.YM + 5*l.YS)
# create stacks
for i in (0, 2.5):
for j in range(6):
x, y = l.XM + j*l.XS, l.YM + i*l.YS
s.rows.append(self.RowStack_Class(x, y, self,
max_move=1, max_accept=1,
dir=0, base_rank=NO_RANK))
x, y = l.XM + 6*l.XS, l.YM
s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT,
max_move=0, max_cards=52, base_rank=ANY_RANK))
l.createText(s.foundations[0], "s")
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=8, reserves=4, playcards=6):
layout, s = Layout(self), self.s
self.setSize(
layout.XM+rows*layout.XS,
layout.YM+3*layout.YS+playcards*layout.YOFFSET)
dx = (self.width-layout.XM-(reserves+1)*layout.XS)//3
x, y = layout.XM+dx, layout.YM
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += layout.XS
x += dx
max_cards = 52*self.gameinfo.decks
s.foundations.append(RK_FoundationStack(x, y, self,
base_rank=ANY_RANK, mod=13, max_cards=max_cards))
layout.createText(s.foundations[0], 'ne')
x, y = layout.XM, layout.YM+layout.YS
for i in range(rows):
s.rows.append(BasicRowStack(x, y, self))
x += layout.XS
s.talon = InitialDealTalonStack(layout.XM, self.height-layout.YS, self)
layout.defaultAll()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 9 * l.XS, l.YM + 2 * l.YS + 12 * l.YOFFSET)
# create stacks
x, y, = l.XM + l.XS, l.YM
for i in range(8):
s.foundations.append(
DieRussische_Foundation(x, y, self, suit=i % 4, max_cards=8))
x += l.XS
x, y, = l.XM + l.XS, l.YM + l.YS
for i in range(8):
s.rows.append(AC_RowStack(x, y, self, max_move=1, max_accept=1))
x += l.XS
s.talon = RedealTalonStack(l.XM, l.YM + l.YS / 2, self, max_rounds=3)
l.createRoundText(s.talon, 'nn')
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=8):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + rows*l.XS, l.YM + 4*l.YS)
# create stacks
x, y, = l.XM, l.YM
s.talon = OpenTalonStack(x, y, self)
l.createText(s.talon, "se")
for i in range(4):
x, y = l.XM + (i+2)*l.XS, l.YM
s.foundations.append(
Strategy_Foundation(x, y, self, suit=i, max_move=0))
x, y = l.XM, l.YM+l.YS
for i in range(rows):
s.rows.append(Strategy_RowStack(x, y,
self, max_move=1, max_accept=1))
x += l.XS
# define stack-groups
l.defaultStackGroups()
self.sg.dropstacks.append(s.talon)
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 9 * l.XS,
max(l.YM + l.YS + 20 * l.YOFFSET, l.YM + 6 * l.YS))
x, y, = l.XM + 1.5 * l.XS, l.YM
for i in range(6):
s.rows.append(LadiesBattle_RowStack(x, y, self, max_move=1,
mod=13))
x = x + l.XS
x, y = l.XM, l.YM + l.YS / 2
for i in range(4):
s.reserves.append(OpenStack(x, y, self, max_accept=0))
y += l.YS
x, y = self.width - l.XS, l.YM + l.YS / 2
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, base_rank=QUEEN,
mod=13))
y += l.YS
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
self.setSize(7 * l.XS + l.XM, 5 * l.YS + l.YM)
# create stacks
for i in range(7):
x = l.XM + (6 - i) * l.XS // 2
y = l.YM + l.YS + i * l.YS // 2
for j in range(i + 1):
s.rows.append(Pyramid_RowStack(x, y, self))
x = x + l.XS
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = Pyramid_Waste(x, y, self, max_accept=1)
l.createText(s.waste, "s")
s.waste.CARD_XOFFSET = 14
x, y = self.width - l.XS, l.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
