def canDropCards(self, stacks):
if self.game.demo:
return RK_RowStack.canDropCards(self, stacks)
for s in self.game.s.foundations:
if s.cards:
return RK_RowStack.canDropCards(self, stacks)
return (None, 0)
def canDropCards(self, stacks):
if self.game.demo:
return RK_RowStack.canDropCards(self, stacks)
for s in self.game.s.foundations:
if s.cards:
return RK_RowStack.canDropCards(self, stacks)
return (None, 0)
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
x, y, = l.XM + 3*l.XS, l.YM
for i in range(4):
s.foundations.append(RK_FoundationStack(x, y, self, max_move=0))
x += l.XS
for i in range(2):
y = l.YM + (i*2+3)*l.YS//2
for j in range(4):
x = l.XM + (j*5)*l.XS//2
stack = RK_RowStack(x, y, self, base_rank=NO_RANK, max_move=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
x, y, = l.XM + 3*l.XS, l.YM + 4*l.YS
s.talon = Bristol_Talon(x, y, self)
l.createText(s.talon, "sw")
x += l.XS
for i in range(3):
stack = WasteStack(x, y, self)
l.createText(stack, 'n')
s.reserves.append(stack)
x += l.XS
# define stack-groups
self.sg.openstacks = s.foundations + s.rows
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows + s.reserves
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM+5*l.XS, l.YM+4*l.YS)
for i, j in ((1, 0),
(2, 0),
(3, 0),
(4, 1.5),
(3, 3),
(2, 3),
(1, 3),
(0, 1.5),
):
x, y = l.XM+i*l.XS, l.YM+j*l.YS
stack = RK_RowStack(x, y, self, dir=1, mod=13, max_move=0)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x, y = l.XM+1.5*l.XS, l.YM+1.5*l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, 'nw')
l.createRoundText(self.s.talon, 'nn')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 5 * l.XS, l.YM + 4 * l.YS)
for i, j in (
(1, 0),
(2, 0),
(3, 0),
(4, 1.5),
(3, 3),
(2, 3),
(1, 3),
(0, 1.5),
):
x, y = l.XM + i * l.XS, l.YM + j * l.YS
stack = RK_RowStack(x, y, self, dir=1, mod=13, max_move=0)
s.rows.append(stack)
stack.CARD_YOFFSET = 0
x, y = l.XM + 1.5 * l.XS, l.YM + 1.5 * l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, 'nw')
l.createRoundText(self.s.talon, 'nn')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 10 * l.XS, l.YM + 5 * l.YS)
# create stacks
x, y, = l.XM + 3 * l.XS, l.YM
for i in range(4):
s.foundations.append(RK_FoundationStack(x, y, self, max_move=0))
x += l.XS
for i in range(2):
y = l.YM + (i * 2 + 3) * l.YS / 2
for j in range(4):
x = l.XM + (j * 5) * l.XS / 2
stack = RK_RowStack(x, y, self, base_rank=NO_RANK, max_move=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
x, y, = l.XM + 3 * l.XS, l.YM + 4 * l.YS
s.talon = Bristol_Talon(x, y, self)
l.createText(s.talon, "sw")
x += l.XS
for i in range(3):
stack = WasteStack(x, y, self)
l.createText(stack, 'n')
s.reserves.append(stack)
x += l.XS
# define stack-groups
self.sg.openstacks = s.foundations + s.rows
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows + s.reserves
def createGame(self):
# create layout
lay, s = Layout(self), self.s
# set window
playcards = 8
w0 = lay.XS + playcards * lay.XOFFSET
w = lay.XM + lay.XS // 2 + max(10 * lay.XS, lay.XS + 4 * w0)
h = lay.YM + 5 * lay.YS + lay.TEXT_HEIGHT
self.setSize(w, h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
lay.createText(s.talon, 's')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, 's')
x = self.width - 8 * lay.XS
for i in range(8):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i % 4, mod=13))
x += lay.XS
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x - lay.XS + tx, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = lay.XM, lay.YM + lay.YS + lay.TEXT_HEIGHT
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
y += lay.YS
y = lay.YM + lay.YS + lay.TEXT_HEIGHT
for i in range(4):
x = lay.XM + lay.XS + lay.XS // 2
for j in range(4):
stack = RK_RowStack(x, y, self, max_move=1, mod=13)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
x += w0
y += lay.YS
# define stack-groups
lay.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)
# extra settings
self.base_card = None
# create stacks
for i in range(4):
dx, dy = ((0, 0), (2, 0), (0, 2), (2, 2))[i]
x, y = l.XM + (2 * dx + 5) * l.XS / 2, l.YM + (2 * dy +
1) * l.YS / 2
stack = SS_FoundationStack(x, y, self, i, mod=13, max_move=0)
stack.CARD_YOFFSET = 0
s.foundations.append(stack)
for i in range(5):
dx, dy = ((1, 0), (0, 1), (1, 1), (2, 1), (1, 2))[i]
x, y = l.XM + (2 * dx + 5) * l.XS / 2, l.YM + (2 * dy +
1) * l.YS / 2
stack = RK_RowStack(x, y, self, mod=13, max_move=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x, y = l.XM, l.YM + 3 * l.YS / 2
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")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
rows = 8
l, s = Layout(self), self.s
self.setSize(l.XM + rows * l.XS, l.YM + 2 * l.YS + 20 * l.YOFFSET)
x, y = l.XM, l.YM
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self))
x += l.XS
x, y = l.XM + (rows - 1) * l.XS // 2, self.height - l.YS
s.foundations.append(
Waterfall_Foundation(x, y, self, suit=ANY_SUIT, max_cards=104))
stack = s.foundations[0]
tx, ty, ta, tf = l.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 - l.XS, self.height - l.YS
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, 'sw')
l.defaultStackGroups()
def createGame(self, rows=9):
l, s = Layout(self), self.s
self.setSize(l.XM+11*l.XS, l.YM+4*l.YS+12*l.YOFFSET)
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 's')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 's')
y = l.YM
for i in range(2):
x = l.XM+2.5*l.XS
for j in range(8):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=j % 4, max_move=1))
x += l.XS
y += l.YS
x, y = l.XM, l.YM+2*l.YS
stack = ReserveStack(x, y, self, max_cards=8)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
l.createText(stack, 'n')
x, y = l.XM+2*l.XS, l.YM+2*l.YS
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self, max_move=1, base_rank=KING))
x += l.XS
l.defaultStackGroups()
def createGame(self, rows=8):
l, s = Layout(self), self.s
w, h = l.XM + rows * l.XS, l.YM + 2 * l.YS + 14 * l.YOFFSET
self.setSize(w, h)
x, y = l.XM, l.YM
for i in range(rows):
s.rows.append(
RK_RowStack(x,
y,
self,
max_cards=13,
mod=13,
dir=1,
max_move=1))
x += l.XS
x, y = l.XM, h - 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')
l.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
# Only allow a sequence if pile is empty
if len(self.cards) > 0:
return False
return True
def createGame(self, rows=8):
# create layout
layout, s = Layout(self), self.s
# set window
playcards = 12
self.setSize(
layout.XM+rows*layout.XS,
layout.YM+3*layout.YS+playcards*layout.YOFFSET)
# create stacks
x, y = layout.XM + (rows-1)*layout.XS//2, layout.YM
stack = RK_FoundationStack(x, y, self, base_rank=ANY_RANK,
max_cards=52, mod=13)
s.foundations.append(stack)
layout.createText(stack, 'ne')
x, y = layout.XM, layout.YM+layout.YS
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self, base_rank=NO_RANK, mod=13))
x += layout.XS
x, y = layout.XM, self.height-layout.YS
s.talon = TalonStack(x, y, self)
layout.createText(s.talon, 'se')
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 10 * l.XS,
l.YM + 2 * l.YS + 12 * l.YOFFSET + l.TEXT_HEIGHT)
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 's')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 's')
x += l.XS
for i in range(8):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i % 4, max_cards=12))
x += l.XS
x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT
s.foundations.append(
RK_FoundationStack(x,
y,
self,
suit=ANY_SUIT,
base_rank=KING,
dir=0,
max_cards=8))
x += 3 * l.XS
for i in range(6):
s.rows.append(RK_RowStack(x, y, self, max_move=1))
x += l.XS
l.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
# Only allow a sequence if pile is empty
if len(self.cards) > 0:
return False
return True
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return (from_stack is self.game.s.talon or
from_stack in self.game.s.reserves)
return True
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return (from_stack is self.game.s.talon
or from_stack in self.game.s.reserves)
return True
def createGame(self):
# create layout
lay, s = Layout(self), self.s
# set window
playcards = 8
w0 = lay.XS+playcards*lay.XOFFSET
w = lay.XM+lay.XS//2+max(10*lay.XS, lay.XS+4*w0)
h = lay.YM+5*lay.YS+lay.TEXT_HEIGHT
self.setSize(w, h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
lay.createText(s.talon, 's')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, 's')
x = self.width - 8*lay.XS
for i in range(8):
s.foundations.append(SS_FoundationStack(x, y, self,
suit=i % 4, mod=13))
x += lay.XS
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x-lay.XS+tx, y+ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = lay.XM, lay.YM+lay.YS+lay.TEXT_HEIGHT
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
y += lay.YS
y = lay.YM+lay.YS+lay.TEXT_HEIGHT
for i in range(4):
x = lay.XM+lay.XS+lay.XS//2
for j in range(4):
stack = RK_RowStack(x, y, self, max_move=1, mod=13)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
x += w0
y += lay.YS
# define stack-groups
lay.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
if cards[0].suit == DIAMOND:
return False
if self.cards:
return self.cards[-1].suit != DIAMOND
return True
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
if cards[0].suit == DIAMOND:
return False
if self.cards:
return self.cards[-1].suit != DIAMOND
return True
def createGame(self, rows=12):
l, s = Layout(self), self.s
self.setSize(l.XM + (rows + 1) * l.XS, l.YM + l.YS + 12 * l.YOFFSET)
x, y = l.XM, l.YM
s.talon = TalonStack(x, y, self)
l.createText(s.talon, "s")
x += l.XS
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self, max_move=1))
x += l.XS
l.defaultStackGroups()
def createGame(self, rows=8, playcards=13, reserve_max_cards=4):
# create layout
l, s = Layout(self), self.s
decks = self.gameinfo.decks
# set window
# (set size so that at least 13 cards are fully playable)
w = max(3*l.XS, l.XS+playcards*l.XOFFSET)
self.setSize(l.XM+2*w+decks*l.XS, l.YM+l.TEXT_HEIGHT+(rows//2+1)*l.YS)
# create stacks
y = l.YM
x = l.XM + w
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
stack = Zerline_ReserveStack(x, y, self, max_cards=reserve_max_cards)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
l.createText(stack, "s")
x = l.XM + w
for j in range(decks):
y = l.YM+l.TEXT_HEIGHT+l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(
x, y, self, i,
base_rank=KING, dir=1, max_move=0, mod=13))
y += l.YS
x += l.XS
x = l.XM
for j in range(2):
y = l.YM+l.TEXT_HEIGHT+l.YS
for i in range(rows//2):
stack = RK_RowStack(
x, y, self, max_move=1, max_accept=1, base_rank=QUEEN)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
x += l.XM+w+decks*l.XS
l.setRegion(
s.rows[:4], (-999, l.YM+l.YS+l.TEXT_HEIGHT-l.CH//2,
w-l.CW//2, 999999))
# define stack-groups
l.defaultStackGroups()
# set regions
l.defaultRegions()
def createGame(self, rows=8):
# create layout
l, s = Layout(self), self.s
# set size
self.setSize(l.XM + (rows+2)*l.XS, l.YM + 5*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
x, y = l.XM, l.YM
for i in range(rows):
stack = RK_RowStack(x, y, self)
stack.CARD_XOFFSET = xoffset
stack.CARD_YOFFSET = yoffset
s.rows.append(stack)
x += l.XS
x, y = l.XM + rows*l.XS, l.YM
for suit in range(4):
for i in range(2):
s.foundations.append(RK_FoundationStack(x+i*l.XS, y, self,
suit=suit))
y += l.YS
self.setRegion(self.s.foundations,
(x - l.CW // 2, -999, 999999, y), priority=1)
x, y = self.width-3*l.XS//2, self.height-l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self, reserves=6):
l, s = Layout(self), self.s
w, h = 3 * l.XM + 5 * l.XS, l.YM + 5 * l.YS
self.setSize(w, h)
lay = (
(0, 2, 0, QUEEN, -1),
(0, 1, 0, QUEEN, -1),
(0, 0, 1, QUEEN, -1),
(2, 0, 1, QUEEN, -1),
(1, 0, 2, QUEEN, -1),
(2, 1, 3, QUEEN, -1),
(2, 2, 3, QUEEN, -1),
(1, 1, 2, KING, 1),
)
for xx, yy, suit, base_rank, dir in lay:
x, y = 2 * l.XM + l.XS + xx * l.XS, l.YM + yy * l.YS
stack = SS_FoundationStack(x,
y,
self,
suit=suit,
max_move=0,
base_rank=base_rank,
dir=dir,
mod=13)
s.foundations.append(stack)
for x, y in ((l.XM, l.YM), (3 * l.XM + 4 * l.XS, l.YM)):
for i in range(5):
stack = RK_RowStack(x,
y,
self,
dir=1,
base_rank=NO_RANK,
max_move=1,
mod=13)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
y += l.YS
x, y = 2 * l.XM + 1.5 * l.XS, l.YM + 4 * 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')
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# (set size so that at least 13 cards are fully playable)
w = max(3 * l.XS, l.XS + 13 * l.XOFFSET)
self.setSize(l.XM + 2 * w + 2 * l.XS, l.YM + 5 * l.YS + l.TEXT_HEIGHT)
# create stacks
x, y = l.XM, l.YM + 4 * l.YS
s.talon = InitialDealTalonStack(x, y, self)
x, y = l.XM + w - l.XS, self.height - l.YS
for i in range(4):
stack = OpenStack(x, y, self, max_accept=0)
s.reserves.append(stack)
l.createText(stack, 'n')
x += l.XS
x = l.XM + w
for x in (l.XM + w, l.XM + w + l.XS):
y = l.YM
for i in range(4):
s.foundations.append(RK_FoundationStack(x, y, self,
max_move=0))
y += l.YS
for x in (l.XM, l.XM + w + 2 * l.XS):
y = l.YM
for i in range(4):
stack = RK_RowStack(x,
y,
self,
max_move=1,
max_accept=1,
base_rank=ANY_RANK)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
l.setRegion(s.rows[:4],
(-999, -999, w - l.CW // 2, l.YM + 4 * l.YS - l.CH // 2))
# define stack-groups
l.defaultStackGroups()
# set regions
l.defaultRegions()
def createGame(self):
# 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, 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
# 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 acceptsCards(self, from_stack, cards):
if not self.cards and from_stack in self.game.s.reserves:
return True
return RK_RowStack.acceptsCards(self, from_stack, cards)
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
return BritishConstitution_RowStackMethods.acceptsCards(
self, from_stack, cards)
def acceptsCards(self, from_stack, cards):
if not self.cards and from_stack in self.game.s.reserves:
return True
return RK_RowStack.acceptsCards(self, from_stack, cards)
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return from_stack is self.game.s.waste
return True
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return from_stack is self.game.s.waste
return True
def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards):
return False
return BritishConstitution_RowStackMethods.acceptsCards(
self, from_stack, cards)
def acceptsCards(self, from_stack, cards):
if self.game.s.talon.cards:
return False
if len(self.cards) == 1:
return True
return RK_RowStack.acceptsCards(self, from_stack, cards)
def acceptsCards(self, from_stack, cards):
if self.cards and not self.game.inSuitSequence(self.cards[-1],
cards[0]):
return False
return RK_RowStack.acceptsCards(self, from_stack, cards)
def basicAcceptsCards(self, from_stack, cards):
if from_stack in self.game.s.rows:
if len(cards) != 1 and len(cards) != len(from_stack.cards):
return False
return RK_RowStack.basicAcceptsCards(self, from_stack, cards)
def basicAcceptsCards(self, from_stack, cards):
if from_stack in self.game.s.rows:
if len(cards) != 1 and len(cards) != len(from_stack.cards):
return False
return RK_RowStack.basicAcceptsCards(self, from_stack, cards)