def updateText(self):
if self.game.preview > 1:
return
WasteTalonStack.updateText(self, update_rounds=0)
if not self.max_rounds - 1:
return
t = _("Round %d") % self.round
self.texts.rounds.config(text=t)
def updateText(self):
if self.game.preview > 1:
return
WasteTalonStack.updateText(self, update_rounds=0)
# t = "Round %d" % self.round
t = _("Round %d/%d") % (self.round, self.max_rounds)
self.texts.rounds.config(text=t)
t = _("Deal %d") % self.DEAL[self.round-1]
self.texts.misc.config(text=t)
def canDealCards(self):
if not WasteTalonStack.canDealCards(self):
return False
for r in self.game.s.reserves:
if not r.cards:
return False
return True
def dealCards(self, sound=False):
if self.round == self.max_rounds:
return 0
if self.cards:
return WasteTalonStack.dealCards(self, sound)
# last round
num_cards = WasteTalonStack.dealCards(self, sound)
wastes = [self.waste]+list(self.game.s.reserves)
old_state = self.game.enterState(self.game.S_DEAL)
if self.cards:
if sound and not self.game.demo:
self.game.startDealSample()
num_cards = min(len(self.cards), 8)
for i in range(num_cards):
if not self.cards[-1].face_up:
self.game.flipMove(self)
self.game.moveMove(1, self, wastes[i], frames=4, shadow=0)
if sound and not self.game.demo:
self.game.stopSamples()
self.game.leaveState(old_state)
return num_cards
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):
l, s = Layout(self), self.s
w1 = l.XS + 12 * l.XOFFSET
w, h = l.XM + 2 * l.XS + 2 * w1, l.YM + 4 * l.YS
self.setSize(w, h)
for x, y in (
(l.XM, l.YM),
(l.XM + w1 + 2 * l.XS + l.XM, l.YM),
(l.XM, l.YM + 3 * l.YS),
(l.XM + w1 + 2 * l.XS + l.XM, l.YM + 3 * l.YS),
):
stack = SS_RowStack(x, y, self, max_move=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
i = 0
for x, y in (
(l.XM + w1, l.YM),
(l.XM + w1 + l.XS, l.YM),
(l.XM + w1 - 2 * l.XS - l.XS / 2 - l.XM, l.YM + 1.5 * l.YS),
(l.XM + w1 - l.XS - l.XS / 2 - l.XM, l.YM + 1.5 * l.YS),
(l.XM + w1 + 2 * l.XS + l.XS / 2 + l.XM, l.YM + 1.5 * l.YS),
(l.XM + w1 + 3 * l.XS + l.XS / 2 + l.XM, l.YM + 1.5 * l.YS),
(l.XM + w1, l.YM + 3 * l.YS),
(l.XM + w1 + l.XS, l.YM + 3 * l.YS),
):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4))
i += 1
x, y = l.XM + w1, l.YM + 1.5 * l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=4)
l.createText(s.talon, 's')
l.createRoundText(s.talon, 'nn')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 's')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
h0 = l.YS + 3 * l.YOFFSET
self.setSize(l.XM + 10 * l.XS, l.YM + l.YS + l.TEXT_HEIGHT + 2 * h0)
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(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4))
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 + l.TEXT_HEIGHT
for i in range(2):
x = l.XM
for j in range(10):
s.rows.append(
DoubleLine_RowStack(x,
y,
self,
max_cards=2,
max_move=1,
max_accept=1,
base_rank=NO_RANK))
x += l.XS
y += h0
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, max_rounds=1):
l, s = Layout(self), self.s
self.setSize(l.XM+11*l.XS, l.YM+5*l.YS)
y = l.YM
for i in range(4):
x = l.XM
for j in range(4):
stack = self.RowStack_Class(x, y, self, max_move=1)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x += l.XS
y += l.YS
y = l.YM
for i in range(4):
x = l.XM+7*l.XS
for j in range(4):
stack = self.RowStack_Class(x, y, self, max_move=1)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x += l.XS
y += l.YS
x, y = l.XM+4.5*l.XS, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
s.foundations.append(SS_FoundationStack(x+l.XS, y, self, suit=i))
y += l.YS
x, y = l.XM+4.5*l.XS, self.height-l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
l.createText(s.talon, 'sw')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'se')
l.defaultStackGroups()
def createGame(self, max_rounds=1):
l, s = Layout(self), self.s
w, h = 3 * l.XM + 5 * l.XS, l.YM + 4 * l.YS
if max_rounds > 1:
h += l.TEXT_HEIGHT + l.TEXT_MARGIN
self.setSize(w, h)
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 = 3 * l.XM + 4 * 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
y = l.YM
for i in range(3):
x = 2 * l.XM + l.XS
for j in range(3):
s.rows.append(
BasicRowStack(x, y, self, max_cards=1, max_accept=1))
x += l.XS
y += l.YS
x, y = 2 * l.XM + l.XS + l.XS // 2, l.YM + 3 * l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds)
x += l.XS
s.waste = WasteStack(x, y, self)
if max_rounds > 1:
l.createText(s.talon, 's')
l.createRoundText(s.talon, 'sss')
l.createText(s.waste, 's')
else:
l.createText(s.talon, 'sw')
l.createText(s.waste, 'se')
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 8 * l.XS, l.YM + 4 * l.YS)
# create stacks
x, y, = l.XM, l.YM
for i in range(4):
s.foundations.append(
self.Foundation_Class(x, y, self, i, dir=2, mod=13))
x = x + l.XS
for i in range(4):
s.foundations.append(
self.Foundation_Class(x,
y,
self,
i,
dir=2,
mod=13,
base_rank=1))
x = x + l.XS
for i in range(2):
x, y, = l.XM + ((4, 3)[i]) * l.XS, l.YM + (i + 1) * l.YS
for j in range((4, 5)[i]):
s.reserves.append(ReserveStack(x, y, self, max_accept=0))
x = x + l.XS
x, y = l.XM, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, "n")
l.createRoundText(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):
l, s = Layout(self), self.s
self.setSize(l.XM + 8 * l.XS, l.YM + 4 * l.YS)
x, y = l.XM, l.YM
for i in range(8):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i // 2,
base_rank=4,
dir=-1,
mod=13,
max_cards=6))
x += l.XS
x, y = l.XM, l.YM + l.YS
for i in range(8):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i // 2,
base_rank=5,
max_cards=7))
x += l.XS
x, y = l.XM + 3 * l.XS, l.YM + 3 * l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, 'n')
l.createRoundText(self.s.talon, 'nnn')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'n')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+7.5*l.XS, l.YM+3.8*l.YS)
x0, y0 = l.XM, l.YM
for xx, yy in ((4, 0.4),
(3, 0.2),
(2, 0.0),
(1, 0.2),
(0, 0.7),
(1, 1.2),
(2, 1.4),
(3, 1.6),
(4, 2.0),
(3, 2.6),
(2, 2.8),
(1, 2.6),
(0, 2.4),
):
x, y = x0+xx*l.XS, y0+yy*l.YS
s.foundations.append(RK_FoundationStack(x, y, self, suit=ANY_SUIT,
max_cards=8, mod=13, max_move=0))
x, y = l.XM+5.5*l.XS, l.YM+2*l.YS
for i in (0, 1):
stack = Calculation_RowStack(x, y, self, max_move=1, max_accept=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
l.createText(stack, 's')
x += l.XS
x, y = l.XM+5.5*l.XS, l.YM+l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'nw')
x += l.XS
s.waste = WasteStack(x, y, self, max_cards=1)
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 8 * l.XS, l.YM + 4 * l.YS + l.TEXT_HEIGHT)
x0 = l.XM + 1.5 * l.XS
for k in (0, 1):
suit = 0
for i, j in ((1, 0), (0, 0.5), (2, 0.5), (1, 1)):
x, y = x0 + i * l.XS, l.YM + j * l.YS
s.foundations.append(AC_FoundationStack(x, y, self, suit=suit))
suit += 1
x0 += 3.5 * l.XS
x, y = l.XM, l.YM + l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS)
l.createText(s.talon, 'se')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'se')
x, y = l.XM + 3.75 * l.XS, l.YM + 2 * l.YS
for i in (0, 1):
stack = KingAC_RowStack(x, y, self, max_move=1)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
x += l.XS
x, y = l.XM + 2.75 * l.XS, l.YM + 3 * l.YS
for i in range(4):
stack = BasicRowStack(x, y, self)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
l.createText(stack, 's')
x += l.XS
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)
# create stacks
for i in range(4):
x, y, = l.XM + i * l.XS, l.YM
s.rows.append(BasicRowStack(x, y, self, max_accept=0))
for i in range(4):
x, y, = l.XM + 4 * l.XS, l.YM + i * l.YS
s.foundations.append(
self.Foundation_Class(x, y, self, i, dir=2, mod=13))
x += l.XS
s.foundations.append(
self.Foundation_Class(x,
y,
self,
i,
dir=2,
mod=13,
base_rank=1))
for i in range(4):
for j in range(4):
x, y, = l.XM + (j + 6) * l.XS, l.YM + i * l.YS
s.reserves.append(ReserveStack(x, y, self, max_accept=0))
x, y = l.XM + l.XS, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "sw")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "se")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 9 * l.XS, l.YM + 5 * l.YS)
# create stacks
x, y = l.XM + l.XS, l.YM
for i in range(8):
s.foundations.append(
BritishConstitution_Foundation(x,
y,
self,
suit=int(i / 2),
max_cards=11))
x += l.XS
y = l.YM + l.YS
for i in range(4):
x = l.XM + l.XS
for j in range(8):
stack = self.RowStack_Class(x, y, self, max_move=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
s.rows.append(stack)
x += l.XS
y += l.YS
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
y += l.YS + l.TEXT_HEIGHT
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 5.5 * l.XS, l.YM + 4 * l.YS)
# create stacks
for dx, dy in ((0, 0), (1, 0), (2, 0), (0, 1), (2, 1), (0, 2), (2, 2)):
x, y = l.XM + (2 * dx + 5) * l.XS // 2, l.YM + (2 * dy +
1) * l.YS // 2
s.rows.append(ReserveStack(x, y, self))
dx, dy = 1, 2
x, y = l.XM + (2 * dx + 5) * l.XS // 2, l.YM + (2 * dy + 1) * l.YS // 2
s.foundations.append(
Doublets_Foundation(x,
y,
self,
ANY_SUIT,
dir=0,
mod=13,
max_move=0,
max_cards=48))
l.createText(s.foundations[0], "s")
# help = "A, 2, 4, 8, 3, 6, Q, J, 9, 5, 10, 7, A, ..."
# self.texts.help = MfxCanvasText(
# self.canvas, x + l.CW//2, y + l.YS + l.YM, anchor="n", text=help)
x, y = l.XM, l.YM + 3 * l.YS // 2
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
l.createRoundText(s.talon, 'nn')
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=16):
# create layout
l, s = Layout(self, card_y_space=20), self.s
# set window
self.setSize(l.XM + (5 + rows // 4) * l.XS, l.YM + 4 * l.YS)
# create stacks
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 = WasteStack(x, y, self)
l.createText(s.waste, "s")
for i in range(4):
x = 3 * l.XS
for j in range(rows // 4):
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 1
s.rows.append(stack)
x = x + l.XS
y = y + l.YS
x, y = self.width - l.XS, l.YM
for i in range(4):
stack = self.Foundation_Class(x,
y,
self,
suit=i,
max_move=0,
dir=0)
l.createText(stack, "sw")
s.foundations.append(stack)
y = y + l.YS
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 8.5 * l.XS, l.YM + 3 * l.YS + 14 * l.XOFFSET)
# create stacks
x, y, = l.XM, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += l.XS
x += l.XS / 2
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.YM + l.YS
for j in range(4):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
x += l.XS / 2
for j in range(4):
s.rows.append(AC_RowStack(x, y, self, dir=1))
x += l.XS
x, y = self.width - 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)
l.createText(s.waste, 'n')
# define stack-groups
l.defaultStackGroups()
def createGame(self):
lay, s = Layout(self), self.s
self.setSize(lay.XM + 8 * lay.XS,
lay.YM + 2 * lay.YS + 12 * lay.YOFFSET)
x, y = lay.XM, lay.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
s.foundations.append(
SS_FoundationStack(x + 4 * lay.XS,
y,
self,
suit=i,
base_rank=KING,
dir=-1))
x += lay.XS
x, y = lay.XM, lay.YM + lay.YS
s.talon = WasteTalonStack(x,
y,
self,
max_rounds=UNLIMITED_REDEALS,
num_deal=3)
lay.createText(s.talon, 'ne')
y += lay.YS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, 'ne')
x, y = lay.XM + 2 * lay.XS, lay.YM + lay.YS
for i in range(4):
s.rows.append(AC_RowStack(x, y, self, base_rank=6))
x += lay.XS
x += lay.XS
stack = OpenStack(x, y, self)
s.reserves.append(stack)
stack.CARD_YOFFSET = lay.YOFFSET
lay.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
w = l.XM + max(7 * l.XS, 2 * l.XS + 23 * l.XOFFSET)
h = l.YM + 5.5 * l.YS
self.setSize(w, h)
x, y = l.XM + (w - 7 * l.XS) // 2, l.YM
s.rows = self._createPyramid(l, x, y, 7)
x, y = l.XM, self.height - l.YS
s.talon = WasteTalonStack(x,
y,
self,
max_rounds=UNLIMITED_REDEALS,
num_deal=3)
l.createText(s.talon, "n")
x += l.XS
s.waste = Pyramid_Waste(x, y, self, max_accept=1)
s.waste.CARD_XOFFSET = l.XOFFSET
l.createText(s.waste, "n")
x, y = self.width - l.XS, l.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))
l.createText(s.foundations[0], 'nw')
l.defaultStackGroups()
self.sg.openstacks.append(s.waste)
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 10 * l.XS, l.YM + 3 * l.YS + 14 * l.YOFFSET)
# create stacks
x, y = l.XM, l.YM
for i in range(7):
s.reserves.append(LockedCards_Reserve(x, y, self))
x += l.XS
x, y = l.XM, l.YM + l.YS
for i in range(8):
s.foundations.append(
self.Foundation_Class(x, y, self, suit=ANY_SUIT, max_move=0))
x += l.XS
x, y = l.XM, l.YM + 2 * l.YS
for i in range(8):
s.rows.append(self.RowStack_Class(x, y, self))
x += l.XS
x, y = self.width - l.XS, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, 'n')
l.createRoundText(s.talon, 'nnn')
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, 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(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, card_x_space=4), self.s
# set window
self.setSize(l.XM + 13 * l.XS, l.YM + 5 * l.YS)
# create stacks
for i in range(4):
for j in range(13):
x, y, = l.XM + j * l.XS, l.YM + i * l.YS
s.rows.append(
PasDeDeux_RowStack(x, y, self, max_accept=1, max_cards=2))
x, y = self.width - 2 * l.XS, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, "se")
l.createRoundText(s.talon, 'ne')
x -= l.XS
s.waste = PasDeDeux_Waste(x, y, self, max_move=0)
l.createText(s.waste, "sw")
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
# define stack-groups
l.defaultStackGroups()
def dealCards(self, sound=False):
self.num_deal = 4-self.round
return WasteTalonStack.dealCards(self, sound=sound)
def canDealCards(self):
if not WasteTalonStack.canDealCards(self):
return False
return not self.game.isGameWon()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 20 cards are playable -
# needed for Ponytail_PonytailStack)
h = max(5*l.YS + l.TEXT_HEIGHT, l.YS+(self.BRAID_CARDS-1)*l.YOFFSET)
self.setSize(10*l.XS+l.XM, l.YM + h)
# extra settings
self.base_card = None
# create stacks
s.addattr(braid=None) # register extra stack variable
x, y = l.XM, l.YM
for i in range(2):
s.rows.append(Ponytail_RowStack(x + 0.5 * l.XS, y, self))
s.rows.append(Ponytail_RowStack(x + 4.5 * l.XS, y, self))
s.rows.append(Ponytail_RowStack(x + 5.5 * l.XS, y, self))
s.rows.append(Ponytail_RowStack(x + 6.5 * l.XS, y, self))
y = y + 4 * l.YS
y = l.YM + l.YS
for i in range(2):
s.rows.append(Ponytail_ReserveStack(x, y, self))
s.rows.append(Ponytail_ReserveStack(x + l.XS, y, self))
s.rows.append(Ponytail_ReserveStack(x, y + l.YS, self))
s.rows.append(Ponytail_ReserveStack(x + l.XS, y + l.YS, self))
s.rows.append(Ponytail_ReserveStack(x, y + 2 * l.YS, self))
s.rows.append(Ponytail_ReserveStack(x + l.XS, y + 2 * l.YS, self))
x = x + 4 * l.XS
x = l.XM + 5*l.XS/2
y = l.YM
s.braid = Ponytail_PonytailStack(x, y, self, sine=1)
x = l.XM + 7 * l.XS
y = l.YM + 2*l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, "s")
s.talon.texts.rounds = MfxCanvasText(
self.canvas,
x + l.CW / 2, y - l.YM,
anchor="s",
font=self.app.getFont("canvas_default"))
x = x - l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
x = l.XM + 8 * l.XS
y = l.YM
for i in range(4):
s.foundations.append(
Ponytail_Foundation(x, y, self, i, mod=14, max_cards=14))
s.foundations.append(
Ponytail_Foundation(
x + l.XS, y, self, i, mod=14, max_cards=14))
y = y + l.YS
s.foundations.append(
Ponytail_Foundation(x, y, self, 4, mod=22, max_cards=22))
s.foundations.append(
Ponytail_Foundation(x + l.XS, y, self, 4, mod=22, max_cards=22))
# ???
self.texts.info = MfxCanvasText(
self.canvas,
x + l.CW + l.XM / 2, y + l.YS,
anchor="n",
font=self.app.getFont("canvas_default"))
# define stack-groups
self.sg.openstacks = s.foundations + s.rows
self.sg.talonstacks = [s.talon] + [s.waste]
self.sg.dropstacks = [s.braid] + s.rows + [s.waste]
def canDealCards(self):
if self.game.getState() == 0:
return False
return WasteTalonStack.canDealCards(self)
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()
def canDealCards(self):
if not WasteTalonStack.canDealCards(self):
return False
return not self.game.isGameWon()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 9.5 * l.XS, l.YM + 5 * l.YS)
# internal stack (for swap)
s.internals.append(InvisibleStack(self))
x0, y0 = l.XM + 1.5 * l.XS, l.YM
# barriers
for xx, yy in (
(0, 2),
(7, 2),
(3.5, 0),
(3.5, 4),
):
x, y = x0 + xx * l.XS, y0 + yy * l.YS
s.rows.append(BasicRowStack(x, y, self, max_accept=0))
# northern hemisphere (red)
for xx, yy in (
(0.5, 1),
(1.5, 0.5),
(2.5, 0.3),
(4.5, 0.3),
(5.5, 0.5),
(6.5, 1),
):
x, y = x0 + xx * l.XS, y0 + yy * l.YS
stack = Hemispheres_RowStack(x,
y,
self,
base_color=RED,
max_move=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
# southern hemisphere (black)
for xx, yy in (
(6.5, 3),
(5.5, 3.5),
(4.5, 3.8),
(2.5, 3.8),
(1.5, 3.5),
(0.5, 3),
):
x, y = x0 + xx * l.XS, y0 + yy * l.YS
stack = Hemispheres_RowStack(x,
y,
self,
base_color=BLACK,
max_move=1,
dir=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
# foundations
x, y = x0 + 2 * l.XS, y0 + 1.5 * l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=2 + i / 2, max_move=0))
x += l.XS
x, y = x0 + 2 * l.XS, y + l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i / 2,
max_move=0,
base_rank=KING,
dir=-1))
x += l.XS
# talon & waste
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 canDealCards(self):
if self.game.base_rank is None:
return False
return WasteTalonStack.canDealCards(self)
def dealCards(self, sound=False):
self.num_deal = 4 - self.round
WasteTalonStack.dealCards(self, sound=sound)
def canDealCards(self):
if self.game.getState() == 0:
return False
return WasteTalonStack.canDealCards(self)
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 20 cards are playable - needed for Braid_BraidStack)
decks = self.gameinfo.decks
h = max(5 * l.YS + 35, l.YS + (self.BRAID_CARDS - 1) * l.YOFFSET)
self.setSize(l.XM + l.XS * (7 + decks * 2), l.YM + h)
# extra settings
self.base_card = None
# Create foundations, rows, reserves
s.addattr(braidstrong=None) # register extra stack variable
s.addattr(braidweak=None) # register extra stack variable
x, y = l.XM, l.YM
for j in range(4):
for i in range(decks):
s.foundations.append(
Triumph_Foundation(x + l.XS * i,
y,
self,
j,
mod=12,
max_cards=12))
s.rows.append(Triumph_StrongStack(x + l.XS * decks, y, self))
s.rows.append(Triumph_ReserveStack(x + l.XS * (1 + decks), y,
self))
y = y + l.YS
x, y = x + l.XS * (5 + decks), l.YM
for j in range(4):
s.rows.append(Triumph_ReserveStack(x, y, self))
s.rows.append(Triumph_WeakStack(x + l.XS, y, self))
for i in range(decks, 0, -1):
s.foundations.append(
Triumph_Foundation(x + l.XS * (1 + i),
y,
self,
j + 4,
mod=12,
max_cards=12))
y = y + l.YS
self.texts.info = MfxCanvasText(
self.canvas,
self.width / 2,
h - l.YM / 2,
anchor="center",
font=self.app.getFont("canvas_default"))
# Create braids
x, y = l.XM + l.XS * 2.3 + l.XS * decks, l.YM
s.braidstrong = Triumph_BraidStack(x,
y,
self,
xoffset=12,
yoffset=self.BRAID_OFFSET)
x += l.XS * 1.4
s.braidweak = Triumph_BraidStack(x,
y,
self,
xoffset=-12,
yoffset=self.BRAID_OFFSET)
# Create talon
x, y = l.XM + l.XS * 2 + l.XS * decks, h - l.YS - l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, "s")
s.talon.texts.rounds = MfxCanvasText(
self.canvas,
self.width / 2,
h - l.YM * 2.5,
anchor="center",
font=self.app.getFont("canvas_default"))
x += l.XS * 2
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# define stack-groups
self.sg.talonstacks = [s.talon] + [s.waste]
self.sg.openstacks = s.foundations + s.rows
self.sg.dropstacks = [s.braidstrong] + [s.braidweak] + s.rows \
+ [s.waste]
def createGame(self):
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# Set window size
self.setSize(7 * l.XS, 5 * l.YS + 3 * l.YM)
# Four winds
TEXTS = (_("North"), _("East"), _("South"), _("West"), _("NW"),
_("NE"), _("SE"), _("SW"))
# Create foundations
x = l.XM * 3
y = l.YM
xoffset = (2.5, 5, 2.5, 0)
yoffset = (0, 2, 4, 2)
for i in range(4):
x0 = x + (xoffset[i] * l.XS)
y0 = y + (yoffset[i] * l.YS)
stack = FourWinds_Foundation(x0,
y0,
self,
-1,
max_cards=12,
max_accept=1,
base_rank=i)
s.foundations.append(stack)
t = MfxCanvasText(self.canvas,
x0 + l.CW // 2,
y0 + l.YS + 5,
anchor="center",
font=font,
text=TEXTS[i])
stack.texts.misc = t
# Create rows
xoffset = (1.25, 3.75, 3.75, 1.25)
yoffset = (0.75, 0.75, 3, 3)
for i in range(4):
x0 = x + (xoffset[i] * l.XS)
y0 = y + (yoffset[i] * l.YS)
stack = FourWinds_RowStack(x0,
y0,
self,
yoffset=10,
max_cards=3,
max_accept=1,
base_rank=ANY_RANK)
s.rows.append(stack)
t = MfxCanvasText(self.canvas,
x0 + l.CW // 2,
y0 + l.YS + 5,
anchor="center",
font=font,
text=TEXTS[i + 4])
stack.texts.misc = t
self.setRegion(
s.rows,
(x + l.XS, y + l.YS * 0.65, x + l.XS * 4 + 5, y + l.YS * 3 + 5))
# Create talon
x = x + 2 * l.XS
y = y + 2 * l.YS
s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=2)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# Define stack-groups
l.defaultStackGroups()
def createGame(self,
max_rounds=1,
num_deal=1,
rows=10,
playcards=12,
XCARDS=64,
XOFFSET=None):
# create layout
if XOFFSET is None:
l, s = Layout(self), self.s
else:
l, s = Layout(self, XOFFSET=XOFFSET), self.s
# set window
# (compute best XOFFSET - up to 64/72 cards can be in the Waste)
decks = self.gameinfo.decks
maxrows = max(rows, 4 * decks)
if maxrows <= 12:
maxrows += 1
w1, w2 = maxrows * l.XS + l.XM, 2 * l.XS
if w2 + XCARDS * l.XOFFSET > w1:
l.XOFFSET = int((w1 - w2) / XCARDS)
# (piles up to 12 cards are playable without overlap
# in default window size)
h = max(2 * l.YS, l.YS + (playcards - 1) * l.YOFFSET)
self.setSize(w1, l.YM + l.YS + h + l.YS + l.TEXT_HEIGHT)
# create stacks
# foundations
x = l.XM + (maxrows - 4 * decks) * l.XS // 2
y = l.YM
for i in range(4 * decks):
s.foundations.append(
self.Foundation_Class(x,
y,
self,
suit=i // decks,
max_move=self.FOUNDATION_MAX_MOVE))
x = x + l.XS
# rows
x = l.XM + (maxrows - rows) * l.XS // 2
y = l.YM + l.YS
for i in range(rows):
s.rows.append(
self.RowStack_Class(x, y, self, max_move=self.ROW_MAX_MOVE))
x = x + l.XS
# talon, waste
x = self.width - l.XS
y = self.height - l.YS
s.talon = WasteTalonStack(x,
y,
self,
max_rounds=max_rounds,
num_deal=num_deal)
l.createText(s.talon, "n")
if max_rounds > 1:
l.createRoundText(s.talon, 'nnn')
x -= l.XS
s.waste = WasteStack(x, y, self)
s.waste.CARD_XOFFSET = -l.XOFFSET
l.createText(s.waste, "n")
# define stack-groups
l.defaultStackGroups()
