def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 5.5 * l.XS, l.YM + 4 * l.YS)
x, y = l.XM, l.YM + l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
l.createText(s.talon, 'ne')
l.createRoundText(s.talon, 'nn')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
x, y = l.XM + 1.5 * l.XS, l.YM
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, max_cards=13))
x += l.XS
x = l.XM + 1.5 * l.XS
y += l.YS
for i in range(4):
s.rows.append(
AbstractFoundationStack(x,
y,
self,
suit=i,
max_cards=1,
max_move=0,
base_rank=QUEEN))
x += l.XS
x = l.XM + 1.5 * l.XS
y += l.YS
for i in range(4):
s.rows.append(
AbstractFoundationStack(x,
y,
self,
suit=i,
max_cards=1,
max_move=0,
base_rank=JACK))
x += l.XS
x = l.XM + 1.5 * l.XS
y += l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i,
mod=13,
max_cards=11,
base_rank=9,
dir=-1))
x += l.XS
l.defaultStackGroups()
def __init__(self, x, y, game, suit, **cap):
kwdefault(cap,
max_cards=12,
max_move=0,
base_rank=ANY_RANK,
base_suit=ANY_SUIT)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return True
dir = self._getDir()
return (self.cards[-1].rank + dir) % self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return True
dir = self._getDir()
return (self.cards[-1].rank+dir) % self.cap.mod == cards[0].rank
def createGame(self):
layout, s = Layout(self), self.s
w0 = layout.XS+5*layout.XOFFSET
self.setSize(layout.XM+5*w0, layout.YM+5*layout.YS)
x, y = layout.XM, layout.YM
for i in range(3):
s.reserves.append(TripleAlliance_Reserve(x, y, self))
x += layout.XS
x, y = self.width-layout.XS, layout.YM
s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
max_move=0, max_accept=0, max_cards=52))
layout.createText(s.foundations[0], 'nw')
y = layout.YM+layout.YS
nstacks = 0
for i in range(4):
x = layout.XM
for j in range(5):
stack = BasicRowStack(x, y, self, max_accept=0)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = layout.XOFFSET, 0
x += w0
nstacks += 1
if nstacks >= 18:
break
y += layout.YS
x, y = self.width-layout.XS, self.height-layout.YS
s.talon = InitialDealTalonStack(x, y, self)
layout.defaultStackGroups()
def createGame(self, rows=6, texts=True):
l, s = Layout(self), self.s
max_rows = max(8, rows)
self.setSize(l.XM + max_rows * l.XS, l.YM + 2 * l.YS + 13 * l.YOFFSET)
x, y = l.XM + l.XS * (max_rows - 4) // 2, l.YM
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x = l.XM + (max_rows - 1) * l.XS
s.foundations.append(
AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_cards=52,
max_accept=0))
l.createText(s.foundations[0], 'nw')
x, y = l.XM + l.XS * (max_rows - rows) // 2, l.YM + l.YS
for i in range(rows):
s.rows.append(UD_AC_RowStack(x, y, self, mod=13))
x += l.XS
s.talon = self.Talon_Class(l.XM, l.YM, self)
if texts:
l.createText(s.talon, 'ne')
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
layout, s = Layout(self), self.s
# set window
h1 = layout.YS+5*layout.YOFFSET
self.setSize(layout.XM+7*layout.XS, layout.YM+2*h1+layout.YS)
# create stacks
y = layout.YM
for i in (0, 1):
x = layout.XM
for j in range(5):
stack = Exit_RowStack(x, y, self, base_rank=NO_RANK,
max_move=1, max_accept=1, dir=0)
s.rows.append(stack)
stack.CARD_YOFFSET = layout.YOFFSET
x += layout.XS
y += h1
x, y = self.width-layout.XS, layout.YM
stack = Exit_RowStack(x, y, self, base_rank=NO_RANK,
max_move=1, max_accept=1, dir=0)
s.reserves.append(stack)
stack.CARD_YOFFSET = layout.YOFFSET
x, y = self.width-layout.XS, self.height-layout.YS
s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
max_accept=0, max_move=0, max_cards=52))
layout.createText(s.foundations[0], "n")
x, y = layout.XM, self.height-layout.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM+5*l.XS, l.YM+3*l.YS)
# create stacks
x, y = l.XM+l.XS, l.YM+2*l.YS
s.talon = RightAndLeft_Talon(x, y, self, max_rounds=UNLIMITED_REDEALS)
l.createText(s.talon, 'se')
x, y = l.XM+0.5*l.XS, l.YM
for i in range(2):
stack = Nestor_RowStack(x, y, self, max_move=1, max_accept=1,
dir=0, base_rank=NO_RANK)
stack.CARD_YOFFSET = 0
l.createText(stack, 's')
s.rows.append(stack)
x += l.XS
x += 1.5*l.XS
s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT,
max_move=0, max_cards=104,
max_accept=0, base_rank=ANY_RANK))
l.createText(s.foundations[0], 's')
# define stack-groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 12 * l.XS, l.YM + 3 * l.YS + 3 * l.YOFFSET)
x, y = l.XM, l.YM
for i in range(12):
s.rows.append(
Nestor_RowStack(x,
y,
self,
max_move=1,
max_accept=1,
dir=0,
base_rank=NO_RANK))
x += l.XS
x, y = l.XM, self.height - l.YS
s.talon = TalonStack(x, y, self)
l.createText(s.talon, 'n')
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=52,
base_rank=ANY_RANK,
max_accept=0))
l.createText(s.foundations[0], "n")
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM + 12 * l.XS, l.YM + l.YS + 16 * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM, l.YM
s.talon = DealRowTalonStack(x, y, self)
l.createText(s.talon, "s")
x += l.XS
for i in range(10):
stack = self.RowStack_Class(x,
y,
self,
base_rank=ANY_RANK,
max_move=UNLIMITED_MOVES,
max_accept=UNLIMITED_ACCEPTS)
s.rows.append(stack)
x += l.XS
s.foundations.append(
AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_accept=0,
max_cards=104))
l.createText(s.foundations[0], "s")
# define stack-groups
l.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
if self.cards:
r1, r2 = self.cards[-1].rank, cards[0].rank
return (r1 + 1) % self.cap.mod == r2
return True
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
if self.cards:
r1, r2 = self.cards[-1].rank, cards[0].rank
return (r1 + 1) % self.cap.mod == r2
return True
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if self.cards:
# check the rank
if (2 * self.cards[-1].rank + 1) % self.cap.mod != cards[0].rank:
return False
return True
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
if len(self.cards) > 12:
return cards[0].rank == 25 - len(self.cards)
else:
return cards[0].rank == len(self.cards)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
if len(self.cards) > 12:
return cards[0].rank == 25 - len(self.cards)
else:
return cards[0].rank == len(self.cards)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if self.cards:
# check the rank
if (2 * self.cards[-1].rank + 1) % self.cap.mod != cards[0].rank:
return False
return True
def createGame(self):
layout, s = Layout(self), self.s
self.setSize(
layout.XM + 9 * layout.XS, layout.YM + 3 * layout.YS +
7 * layout.YOFFSET + 2 * layout.TEXT_HEIGHT)
x, y = layout.XM + 4 * layout.XS, layout.YM
stack = DevilsSolitaire_Foundation(x,
y,
self,
suit=ANY_SUIT,
base_rank=ANY_RANK,
mod=13)
tx, ty, ta, tf = layout.getTextAttr(stack, 'nw')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
s.foundations.append(stack)
x, y = self.width - layout.XS, layout.YM
stack = AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
max_move=0,
max_cards=104,
max_accept=0,
base_rank=ANY_RANK)
layout.createText(stack, 'nw')
s.foundations.append(stack)
x, y = layout.XM, layout.YM + layout.YS
for i in range(4):
s.rows.append(Vague_RowStack(x, y, self))
x += layout.XS
x += layout.XS
for i in range(4):
s.rows.append(Vague_RowStack(x, y, self))
x += layout.XS
x, y = layout.XM + 4 * layout.XS, layout.YM + layout.YS
stack = OpenStack(x, y, self)
stack.CARD_YOFFSET = layout.YOFFSET
s.reserves.append(stack)
x, y = layout.XM + 4.5 * layout.XS, self.height - layout.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=3)
layout.createText(s.talon, 'n')
layout.createRoundText(s.talon, 'nnn')
x -= layout.XS
s.waste = DevilsSolitaire_WasteStack(x, y, self)
layout.createText(s.waste, 'n')
layout.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
c = cards[0]
for s in self.game.s.rows:
if s is not from_stack and s.cards and s.cards[-1].suit == c.suit:
if s.cards[-1].rank > c.rank or s.cards[-1].rank == ACE:
# found a higher rank or an Ace on the row stacks
return c.rank != ACE
return False
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
c = cards[0]
for s in self.game.s.rows:
if s is not from_stack and s.cards and s.cards[-1].suit == c.suit:
if s.cards[-1].rank > c.rank or s.cards[-1].rank == ACE:
# found a higher rank or an Ace on the row stacks
return c.rank != ACE
return False
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if self.game.base_rank is None:
return True
if not self.cards:
return cards[-1].rank == self.game.base_rank
# check the rank
return (self.cards[-1].rank + self.cap.dir) % \
self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if self.game.base_rank is None:
return True
if not self.cards:
return cards[-1].rank == self.game.base_rank
# check the rank
return (self.cards[-1].rank + self.cap.dir) % \
self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if self.cards:
# check the rank - an ACE equals a Six
rank = self.cards[-1].rank
if rank == ACE:
rank = 5
if (rank + self.cap.dir) % self.cap.mod != cards[0].rank:
return False
return True
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
ww = l.XS + max(2 * l.XOFFSET, l.XS // 2)
w = l.XM + 1.5 * l.XS + 4 * ww
h = l.YM + 3 * l.YS
self.setSize(w, h)
# create stacks
for xx, yy in (
(0, 0),
(1, 0),
(2, 0),
(3, 0),
(0, 1),
(3, 1),
(0, 2),
(1, 2),
(2, 2),
(3, 2),
):
x, y = l.XM + 1.5 * l.XS + ww * xx, l.YM + l.YS * yy
stack = Hurricane_Reserve(x, y, self, max_accept=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.reserves.append(stack)
d = 3 * ww - 4 * l.XS - 2 * l.XOFFSET
x = l.XM + 1.5 * l.XS + l.XS + 2 * l.XOFFSET + d // 2
y = l.YM + l.YS
for i in range(3):
stack = Hurricane_RowStack(x, y, self, max_accept=1)
s.rows.append(stack)
x += l.XS
x, y = l.XM, l.YM
s.talon = TalonStack(x, y, self)
l.createText(s.talon, 'ne')
y += 2 * l.YS
s.foundations.append(
AbstractFoundationStack(x,
y,
self,
suit=ANY_SUIT,
dir=0,
base_rank=ANY_RANK,
max_accept=0,
max_move=0,
max_cards=52))
l.createText(s.foundations[0], 'ne')
# define stack-groups
l.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return 0
if not self.cards:
return cards[0].suit == self.game.base_card.suit
stack_dir = self.game.getFoundationDir()
if stack_dir == 0:
card_dir = (cards[0].suit - self.cards[-1].suit) % 12
return card_dir in (1, 11)
else:
return (self.cards[-1].suit + stack_dir) % 12 == cards[0].suit
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if self.cards:
# check the rank - an ACE equals a Six
rank = self.cards[-1].rank
if rank == ACE:
rank = 5
if (rank + self.cap.dir) % self.cap.mod != cards[0].rank:
return False
return True
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return 0
if not self.cards:
return cards[0].suit == self.game.base_card.suit
stack_dir = self.game.getFoundationDir()
if stack_dir == 0:
card_dir = (cards[0].suit - self.cards[-1].suit) % 12
return card_dir in (1, 11)
else:
return (self.cards[-1].suit + stack_dir) % 12 == cards[0].suit
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return True
stack_dir = self.game.getFoundationDir()
if stack_dir == 0:
card_dir = self.getRankDir(cards=(self.cards[-1], cards[0]))
return card_dir in (1, -1)
else:
return ((self.cards[-1].rank + stack_dir) %
self.cap.mod == cards[0].rank)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return 0
if not self.cards:
return 1
stack_dir = self.game.getFoundationDir()
if stack_dir == 0:
card_dir = (cards[0].rank - self.cards[-1].rank) % self.cap.mod
return card_dir in (1, 15)
else:
return (self.cards[-1].rank + stack_dir) % self.cap.mod \
== cards[0].rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return 0
if not self.cards:
return 1
stack_dir = self.game.getFoundationDir()
if stack_dir == 0:
card_dir = (cards[0].rank - self.cards[-1].rank) % self.cap.mod
return card_dir in (1, 11)
else:
return (self.cards[-1].rank + stack_dir) % \
self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards):
if not (from_stack in self.game.s.rows and
AbstractFoundationStack.acceptsCards(self, from_stack, cards)):
return 0
pile, rank, suit = from_stack.getPile(), 0, 0
if self.cards:
rank = (self.cards[-1].rank + 1) % 12
suit = self.cards[-1].suit + (rank == 0)
if (not pile or len(pile) <= 11 - rank or
not isSameSuitSequence(pile[-(12 - rank):])):
return 0
return cards[0].suit == suit and cards[0].rank == rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return True
stack_dir = self.game.getFoundationDir()
if stack_dir == 0:
card_dir = self.getRankDir(cards=(self.cards[-1], cards[0]))
return card_dir in (1, -1)
else:
return ((self.cards[-1].rank + stack_dir) %
self.cap.mod == cards[0].rank)
def acceptsCards(self, from_stack, cards):
if not (from_stack in self.game.s.rows and
AbstractFoundationStack.acceptsCards(self, from_stack, cards)):
return 0
pile, rank, suit = from_stack.getPile(), 0, 0
if self.cards:
rank = (self.cards[-1].rank + 1) % 12
suit = self.cards[-1].suit + (rank == 0)
if (not pile or len(pile) <= 11 - rank
or not isSameSuitSequence(pile[-(12 - rank):])):
return 0
return cards[0].suit == suit and cards[0].rank == rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
# 7, 8, 9, 10, J, Q, K, A, K, Q, J, 10, 9, 8, 7, A
if len(self.cards) < 7:
return cards[0].rank - 6 == len(self.cards)
elif len(self.cards) == 7:
return cards[0].rank == ACE
elif len(self.cards) < 15:
return cards[0].rank == 20 - len(self.cards)
else: # len(self.cards) == 15
return cards[0].rank == ACE
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
# 7, 8, 9, 10, J, Q, K, A, K, Q, J, 10, 9, 8, 7, A
if len(self.cards) < 7:
return cards[0].rank - 6 == len(self.cards)
elif len(self.cards) == 7:
return cards[0].rank == ACE
elif len(self.cards) < 15:
return cards[0].rank == 20 - len(self.cards)
else: # len(self.cards) == 15
return cards[0].rank == ACE
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
c1 = cards[0]
if not self.cards:
return c1.rank == ACE and c1.suit == 0
c2 = self.cards[-1]
if c2.rank == KING:
suit = (c2.suit+1) % 4
rank = ACE
else:
suit = c2.suit
rank = c2.rank+1
return c1.suit == suit and c1.rank == rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
c1 = cards[0]
if not self.cards:
return c1.rank == ACE and c1.suit == 0
c2 = self.cards[-1]
if c2.rank == KING:
suit = (c2.suit+1) % 4
rank = ACE
else:
suit = c2.suit
rank = c2.rank+1
return c1.suit == suit and c1.rank == rank
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# search foundation with max number of cards
assert len(cards) == 1
max_s, max_cards = None, -1
for s in self.game.s.foundations:
if len(s.cards) > max_cards:
max_s, max_cards = s, len(s.cards)
# if we have less cards, then rank must match the card in this
# foundation
if len(self.cards) < max_cards:
if cards[0].rank != max_s.cards[len(self.cards)].rank:
return False
#
return True
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# search foundation with max number of cards
assert len(cards) == 1
max_s, max_cards = None, -1
for s in self.game.s.foundations:
if len(s.cards) > max_cards:
max_s, max_cards = s, len(s.cards)
# if we have less cards, then rank must match the card in this
# foundation
if len(self.cards) < max_cards:
if cards[0].rank != max_s.cards[len(self.cards)].rank:
return False
#
return True
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=3, cols=3, reserves=3, texts=False):
l, s = Layout(self), self.s
self.setSize(l.XM + (cols + 2) * l.XS, l.YM + (rows + 1.5) * l.YS)
x, y = self.width - l.XS, l.YM
s.talon = TalonStack(x, y, self)
l.createText(s.talon, 's')
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')
y = l.YM
for i in range(rows):
x = l.XM
for j in range(cols):
s.rows.append(self.RowStack_Class(x, y, self, max_accept=1))
x += l.XS
y += l.YS
x, y = l.XM, self.height - l.YS
for i in range(reserves):
stack = self.Reserve_Class(x, y, self)
s.reserves.append(stack)
stack.CARD_XOFFSET = l.XOFFSET # for fifteens
x += l.XS
if texts:
stack = s.reserves[0]
tx, ty, ta, tf = l.getTextAttr(stack, "n")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
l.defaultStackGroups()
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if from_stack not in self.game.s.rows:
return False
if cards[0].rank == ACE:
return True
if not self.cards:
return False
rank = self.cards[-1].rank
if rank == ACE:
rank = 5
if (rank + self.cap.dir) % self.cap.mod != cards[0].rank:
return False
if cards[0].rank == QUEEN:
return True
i = list(self.game.s.foundations).index(self)
j = list(self.game.s.rows).index(from_stack)
return i == j
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
if from_stack not in self.game.s.rows:
return False
if cards[0].rank == ACE:
return True
if not self.cards:
return False
rank = self.cards[-1].rank
if rank == ACE:
rank = 5
if (rank + self.cap.dir) % self.cap.mod != cards[0].rank:
return False
if cards[0].rank == QUEEN:
return True
i = list(self.game.s.foundations).index(self)
j = list(self.game.s.rows).index(from_stack)
return i == j
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
assert len(cards) == 1
indx = list(self.game.s.foundations).index(self)
c0 = cards[0]
below_found = self.game.s.foundations[indx-1]
if indx == 0:
if not self.cards:
return True
return c0.suit == self.cards[0].suit
if not below_found.cards:
return False
if not self.cards:
return c0.rank == below_found.cards[0].rank
if c0.suit != self.cards[0].suit:
return False
for c1 in below_found.cards:
if c0.rank == c1.rank:
return True
return False
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
assert len(cards) == 1
indx = list(self.game.s.foundations).index(self)
c0 = cards[0]
below_found = self.game.s.foundations[indx-1]
if indx == 0:
if not self.cards:
return True
return c0.suit == self.cards[0].suit
if not below_found.cards:
return False
if not self.cards:
return c0.rank == below_found.cards[0].rank
if c0.suit != self.cards[0].suit:
return False
for c1 in below_found.cards:
if c0.rank == c1.rank:
return True
return False
def __init__(self, x, y, game, suit, **cap):
kwdefault(cap, max_cards=12, max_move=0, base_rank=ANY_RANK,
base_suit=ANY_SUIT)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# We accept any King. Pairs will get delivered by _dropPairMove.
return cards[0].rank == KING
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
return ((self.cards[-1].rank+1) % 13 == cards[0].rank or
(self.cards[-1].rank-1) % 13 == cards[0].rank)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
return isRankSequence(cards, dir=0)
def __init__(self, x, y, game, suit=ANY_SUIT, **cap):
kwdefault(cap, max_move=0, max_accept=0, max_cards=game.NCARDS)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def __init__(self, x, y, game, suit, **cap):
kwdefault(cap, mod=12, dir=0, base_rank=NO_RANK, max_move=0)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
return isSameColorSequence(cards, self.cap.mod, self.cap.dir)
def updateText(self):
AbstractFoundationStack.updateText(self)
self.game.updateText()
def __init__(self, x, y, game, suit, **cap):
kwdefault(cap, base_suit=0, mod=12, max_cards=120, max_move=0)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def __init__(self, x, y, game, suit, **cap):
kwdefault(cap, mod=12, dir=0, base_suit=ANY_SUIT, max_move=0)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
return False
# We accept any King. Pairs will get delivered by _dropPairMove.
return cards[0].rank == KING
def __init__(self, x, y, game, suit, **cap):
kwdefault(cap, max_move=0, max_cards=48, max_accept=4, min_accept=4)
AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
self.CARD_YOFFSET = self.game.app.images.CARDH // 10
