def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 8*l.XS, l.YM + 2*l.YS+16*l.YOFFSET)
# create stacks
x, y, = l.XM, l.YM
for i in range(8):
if self.Foundation_Class is RK_FoundationStack:
suit = ANY_SUIT
else:
suit = int(i//2)
s.foundations.append(self.Foundation_Class(x, y, self,
suit=suit, max_move=0))
x += l.XS
x, y = l.XM, l.YM+l.YS
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, "s")
x += l.XS
s.waste = WasteStack(x, y, self, max_cards=1)
x += l.XS
for i in range(5):
stack = Numerica_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS)
# stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.rows.append(stack)
x = x + l.XS
# define stack-groups
l.defaultStackGroups()
def _position(self, card):
OpenStack._position(self, card)
#
if TOOLKIT == 'tk':
rows = [s for s in self.game.s.rows[:self.id] if s.cards]
if rows:
self.group.tkraise(rows[-1].group)
return
rows = [s for s in self.game.s.rows[self.id+1:] if s.cards]
if rows:
self.group.lower(rows[0].group)
return
elif TOOLKIT == 'kivy':
rows = [s for s in self.game.s.rows[:self.id] if s.cards]
if rows:
# self.group.tkraise(rows[-1].group)
return
rows = [s for s in self.game.s.rows[self.id+1:] if s.cards]
if rows:
# self.group.lower(rows[0].group)
return
elif TOOLKIT == 'gtk':
# FIXME (this is very slow)
for s in self.game.s.rows[self.id+1:]:
s.group.tkraise()
def createGame(self, rows=8, reserves=8, playcards=7):
# create layout
l, s = Layout(self), self.s
# set window
max_rows = max(rows, reserves)
w, h = l.XM + max_rows*l.XS, l.YM + 2*l.YS + (12+playcards)*l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM + (max_rows-rows)*l.XS//2, l.YM
for i in range(rows):
stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
x += l.XS
x, y = l.XM + (max_rows-reserves)*l.XS//2, l.YM+l.YS+12*l.YOFFSET
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
x += l.XS
s.talon = InitialDealTalonStack(l.XM, l.YM, self)
# default
l.defaultAll()
def createGame(self):
# create layout
lay, s = Layout(self), self.s
# set window
w = max(8*lay.XS, 6*lay.XS+8*lay.XOFFSET)
h = lay.YM+3*lay.YS+12*lay.YOFFSET
self.setSize(w+lay.XM, h)
# create stacks
y = lay.YM
for x in (lay.XM, lay.XM+w-lay.XS-4*lay.XOFFSET):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0
s.reserves.append(stack)
x, y = lay.XM+(w-4*lay.XS)//2, lay.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += lay.XS
x, y = lay.XM+(w-8*lay.XS)//2, lay.YM+lay.YS
for i in range(8):
s.rows.append(AC_RowStack(x, y, self))
x += lay.XS
s.talon = WasteTalonStack(lay.XM, h-lay.YS, self, max_rounds=1)
lay.createText(s.talon, "n")
s.waste = WasteStack(lay.XM+lay.XS, h-lay.YS, self)
lay.createText(s.waste, "n")
# define stack-groups
lay.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 __init__(self, x, y, game, yoffset=-1, **cap):
kwdefault(
cap, max_move=UNLIMITED_MOVES,
max_accept=UNLIMITED_ACCEPTS, dir=-1)
OpenStack.__init__(self, x, y, game, **cap)
if yoffset < 0:
yoffset = game.app.images.CARD_YOFFSET
self.CARD_YOFFSET = yoffset
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
OpenStack.moveMove(self, ncards, to_stack, frames, shadow)
if self.game.base_rank is None and to_stack in self.game.s.foundations:
old_state = self.game.enterState(self.game.S_FILL)
self.game.saveStateMove(2 | 16) # for undo
self.game.base_rank = to_stack.cards[-1].rank
self.game.saveStateMove(1 | 16) # for redo
self.game.leaveState(old_state)
def __init__(self, x, y, game):
OpenStack.__init__(self, x, y, game)
self.CARD_YOFFSET = self.game.app.images.CARD_YOFFSET
# use a sine wave for the x offsets
self.CARD_XOFFSET = []
j = 1
for i in range(20):
self.CARD_XOFFSET.append(int(math.sin(j) * 20))
j = j + .9
def __init__(self, x, y, game, xoffset, yoffset):
OpenStack.__init__(self, x, y, game)
self.CARD_YOFFSET = int(self.game.app.images.CARD_YOFFSET * yoffset)
# use a sine wave for the x offsets
self.CARD_XOFFSET = []
j = 1
for i in range(30):
self.CARD_XOFFSET.append(int(math.cos(j) * xoffset))
j = j + .9
def __init__(self, x, y, game, yoffset):
OpenStack.__init__(self, x, y, game)
self.CARD_YOFFSET = int(self.game.app.images.CARD_YOFFSET * yoffset)
# use a sine wave for the x offsets
# compensate for card width
offset = self.game.app.images.CARDW / 1.7
self.CARD_XOFFSET = []
j = 1
for i in range(20):
self.CARD_XOFFSET.append(int(math.sin(j) * offset))
j = j + .9
def _position(self, card):
# AbstractFoundationStack._position(self, card)
OpenStack._position(self, card)
fnds = self.game.s.foundations
cols = (3, 2, 1, 0)
for i in cols:
for j in range(9):
n = i*9+j
if fnds[n].cards:
fnds[n].group.tkraise()
return
def createGame(self, rows=1, reserves=8, playcards=3):
# create layout
l, s = Layout(self), self.s
# set window
w, h = l.XM+8*l.XS, l.YM+3.5*l.YS+playcards*l.YOFFSET
h += l.TEXT_HEIGHT
self.setSize(w, h)
# create stacks
x, y, = l.XM, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
max_move=0))
x += l.XS
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i,
max_move=0, base_rank=KING, dir=-1))
x += l.XS
x, y, = l.XM+(8-reserves)*l.XS//2, y+l.YS
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
x, y = l.XM+(8-1-rows)*l.XS//2, self.height-l.YS
s.talon = Alhambra_Talon(x, y, self, max_rounds=3)
if rows == 1:
l.createText(s.talon, 'sw')
else:
l.createText(s.talon, 'n')
anchor = 'nn'
if rows > 1:
anchor = 'nnn'
l.createRoundText(s.talon, anchor)
x += l.XS
for i in range(rows):
stack = self.RowStack_Class(x, y, self, mod=13, max_accept=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0
s.rows.append(stack)
x += l.XS
if rows == 1:
l.createText(stack, 'se')
else:
l.createText(stack, 'n')
# define stack-groups (non default)
l.defaultStackGroups()
def canFlipCard(self):
if not OpenStack.canFlipCard(self):
return False
for r in self.game.s.reserves:
if len(r.cards) > 2:
return False
return True
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
if self.cards[-1].rank != cards[0].rank:
return False
# now look if the stacks are neighbours
return self.game.isNeighbour(from_stack, self)
def __init__(self, x, y, game, sine=0):
OpenStack.__init__(self, x, y, game)
self.CARD_YOFFSET = self.game.app.images.CARD_YOFFSET
CW = self.game.app.images.CARDW
if sine:
# use a sine wave for the x offsets
self.CARD_XOFFSET = []
n = 9
dx = 0.4 * CW * (2*math.pi/n)
last_x = 0
for i in range(n):
x = int(round(dx * math.sin(i + 1)))
# print x, x - last_x
self.CARD_XOFFSET.append(x - last_x)
last_x = x
else:
self.CARD_XOFFSET = (-0.45*CW, 0.35*CW, 0.55*CW, -0.45*CW)
def clickHandler(self, event):
result = OpenStack.doubleclickHandler(self, event)
if result == 1 and not self.game.score_counted:
self.game.sequence += 1
self.game.computeHandScore()
self.game.updateText()
elif self.game.score_counted:
self.game.score_counted = False
return result
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return False
# check the rank
if self.cards[-1].rank + cards[0].rank + 2 == 10:
return True
if self.cards[-1].rank > 9 and self.cards[-1].rank == cards[0].rank:
return True
return False
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
# (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):
l, s = Layout(self), self.s
# Set window size
decks = self.gameinfo.decks
self.setSize(2 * l.XM + (2 + 5 * decks) * l.XS, 3 * l.YM + 5 * l.YS)
yoffset = min(l.YOFFSET, max(10, l.YOFFSET / 2))
# Create talon
x = l.XM
y = l.YM
s.talon = WasteTalonStack(x,
y,
self,
num_deal=1,
max_rounds=self.MAX_ROUNDS)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
# Create foundations
x = x + l.XM + l.XS
for j in range(4):
for i in range(decks):
s.foundations.append(
SS_FoundationStack(x, y, self, j, max_cards=14))
x = x + l.XS
for i in range(decks):
s.foundations.append(
SS_FoundationStack(x, y, self, 4, max_cards=22))
x = x + l.XS
# Create reserve
x = l.XM
y = l.YM + l.YS + l.TEXT_HEIGHT
s.reserves.append(OpenStack(x, y, self))
s.reserves[0].CARD_YOFFSET = (l.YOFFSET, yoffset)[decks == 2]
# Create rows
x = x + l.XM + l.XS
for i in range(decks):
s.rows.append(TrumpOnly_RowStack(x, y, self, yoffset=yoffset))
x = x + l.XS
for i in range(4 * decks + 1):
s.rows.append(Tarock_AC_RowStack(x, y, self))
x = x + l.XS
self.setRegion(s.rows, (-999, y - l.YS, 999999, 999999))
# Define stack groups
l.defaultStackGroups()
def createGame(self, reserves=3, rows=5):
# create layout
l, s = Layout(self), self.s
# set window
n = 52 // reserves + 1
w, h = l.XM + (reserves + rows +
1) * l.XS, l.YM + 2 * l.YS + n * l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM + (reserves + rows + 1 - 4) * l.XS // 2, l.YM
for i in range(4):
if self.Foundation_Class is RK_FoundationStack:
suit = ANY_SUIT
else:
suit = i
s.foundations.append(
self.Foundation_Class(x, y, self, suit=suit, max_move=0))
x += l.XS
x, y = l.XM, l.YM + l.YS
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
x += l.XS
for i in range(rows):
s.rows.append(
Gloaming_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS))
x += l.XS
s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self)
# default
l.defaultAll()
def canFlipCard(self):
if not OpenStack.canFlipCard(self):
return False
for s in self.game.s.rows:
if not s.cards:
break
else:
return False
i = list(self.game.s.reserves).index(self)
if i == 0:
return True
if self.game.s.reserves[i - 1].cards:
return False
return True
def canFlipCard(self):
if not OpenStack.canFlipCard(self):
return False
for s in self.game.s.rows:
if not s.cards:
break
else:
return False
i = list(self.game.s.reserves).index(self)
if i == 0:
return True
if self.game.s.reserves[i-1].cards:
return False
return True
def createGame(self, reserves=3, rows=5):
# create layout
l, s = Layout(self), self.s
# set window
n = 52//reserves+1
w, h = l.XM + (reserves+rows+1)*l.XS, l.YM + 2*l.YS+n*l.YOFFSET
self.setSize(w, h)
# create stacks
x, y = l.XM+(reserves+rows+1-4)*l.XS//2, l.YM
for i in range(4):
if self.Foundation_Class is RK_FoundationStack:
suit = ANY_SUIT
else:
suit = i
s.foundations.append(self.Foundation_Class(x, y, self,
suit=suit, max_move=0))
x += l.XS
x, y = l.XM, l.YM+l.YS
for i in range(reserves):
stack = OpenStack(x, y, self, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET
s.reserves.append(stack)
x += l.XS
x += l.XS
for i in range(rows):
s.rows.append(
Gloaming_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS))
x += l.XS
s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self)
# default
l.defaultAll()
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return True
if cards[0].suit != self.cards[0].suit:
return False
if len(self.cards) == 1:
card_dir = cards[0].rank - self.cards[-1].rank
return card_dir == 1 or card_dir == -1
else:
stack_dir = (self.cards[1].rank - self.cards[0].rank) % \
self.cap.mod
return (self.cards[-1].rank + stack_dir) % \
self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return False
if not self.cards:
return True
if cards[0].suit != self.cards[0].suit:
return False
if len(self.cards) == 1:
card_dir = cards[0].rank - self.cards[-1].rank
return card_dir == 1 or card_dir == -1
else:
stack_dir = (self.cards[1].rank - self.cards[0].rank) % \
self.cap.mod
return (self.cards[-1].rank + stack_dir) % \
self.cap.mod == cards[0].rank
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):
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 createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 8 * l.XS, l.YM + 5 * l.YS)
x0, y0 = l.XM + 2 * l.XS, l.YM
# foundations (corners)
suit = 0
for i, j in ((0, 0), (5, 0), (0, 4), (5, 4)):
x, y = x0 + i * l.XS, y0 + j * l.YS
s.foundations.append(
Frames_Foundation(x, y, self, suit=suit, dir=0, max_cards=26))
suit += 1
# rows (frame)
for i in (1, 2, 3, 4):
for j in (0, 4):
x, y = x0 + i * l.XS, y0 + j * l.YS
stack = Frames_RowStack(x, y, self)
s.rows.append(stack)
stack.cap.addattr(column=i)
stack.CARD_YOFFSET = 0
for i in (0, 5):
for j in (1, 2, 3):
x, y = x0 + i * l.XS, y0 + j * l.YS
stack = Frames_RowStack(x, y, self)
s.rows.append(stack)
stack.cap.addattr(row=j)
stack.CARD_YOFFSET = 0
# reserves (picture)
for j in (1, 2, 3):
for i in (1, 2, 3, 4):
x, y = x0 + i * l.XS, y0 + j * l.YS
stack = OpenStack(x, y, self)
s.reserves.append(stack)
stack.cap.addattr(column=i)
stack.cap.addattr(row=j)
# 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 playFlipMove(self, sound=True, animation=False):
rows = int(math.sqrt(self.game.gameinfo.ncards))
playSpace = self.id
if playSpace % rows != rows - 1:
self.game.s.rows[playSpace + 1].flipMove()
if playSpace % rows != 0:
self.game.s.rows[playSpace - 1].flipMove()
if playSpace + rows < rows**2:
self.game.s.rows[playSpace + rows].flipMove()
if playSpace - rows >= 0:
self.game.s.rows[playSpace - rows].flipMove()
return OpenStack.playFlipMove(self, sound, animation)
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
y = l.YM
for i in range(2):
x = l.XM + 3 * l.XS
for j in range(4):
s.foundations.append(
TwilightZone_Foundation(x, y, self, suit=j))
x += l.XS
y += l.YS
x, y = l.XM + 3 * l.XS, l.YM + 2 * l.YS
for i in range(4):
stack = TwilightZone_RowStack(x, y, self, max_move=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x += l.XS
x, y = l.XM + 3 * l.XS, l.YM + 4 * l.YS
for i in range(4):
s.reserves.append(OpenStack(x, y, self))
x += l.XS
x, y = l.XM, l.YM + l.YS / 2
s.talon = TwilightZone_Talon(x, y, self, max_move=1, max_rounds=2)
l.createText(s.talon, 's')
l.createRoundText(s.talon, 'nn')
x += l.XS
s.waste = TwilightZone_Waste(x, y, self, max_accept=1)
l.createText(s.waste, 's')
# define stack-groups
l.defaultStackGroups()
self.sg.dropstacks.append(s.talon)
self.sg.openstacks.append(s.waste)
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):
# create layout
l, s = Layout(self), self.s
s.addattr(xwastes=[]) # register extra stack variable
# set window
w, h = l.XM + 11 * l.XS, l.YM + 6 * l.YS
self.setSize(w, h)
# create stacks
x, y, = l.XM, l.YM
s.talon = Interment_Talon(x, y, self)
l.createText(s.talon, 'ne')
x += 1.5 * 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
for i in range(3):
stack = Interment_Waste(x, y, self, max_cards=UNLIMITED_CARDS)
l.createText(stack, 'ne')
s.xwastes.append(stack)
y += l.YS
x, y = l.XM + 1.5 * l.XS, l.YM + l.YS
for i in range(8):
s.rows.append(SS_RowStack(x, y, self, max_move=1))
x += l.XS
x, y = self.width - l.XS, l.YM
stack = Interment_Reserve(x, y, self)
s.reserves.append(stack)
l.createText(stack, 'nw')
y += l.YS
for i in range(5):
s.reserves.append(OpenStack(x, y, self))
y += l.YS
# define stack-groups
l.defaultStackGroups()
self.sg.dropstacks += s.xwastes
self.sg.openstacks += s.xwastes
self.sg.dropstacks.append(s.talon)
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w, h = max(2 * l.XM + 2 * l.XS + (5 + 13) * l.XOFFSET,
l.XM + 8 * l.XS), l.YM + 8 * l.YS
self.setSize(w, h)
# create stacks
x, y, = l.XM, l.YM
for i in range(4):
stack = BasicRowStack(x, y, self, max_move=1, max_accept=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack)
y += l.YS
x, y, = 2 * l.XM + l.XS + 5 * l.XOFFSET, l.YM
for i in range(4):
stack = Osmosis_Foundation(x,
y,
self,
i,
base_rank=ANY_RANK,
max_move=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.foundations.append(stack)
y += l.YS
y = l.YM + 4 * l.YS
for i in range(4):
x = l.XM
for j in range(8):
s.reserves.append(OpenStack(x, y, self, max_accept=0))
x += l.XS
y += l.YS
x, y = w - l.XS, l.YM
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
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 __init__(self, x, y, game, **cap):
kwdefault(cap, max_cards=1, max_accept=1, base_rank=ANY_RANK)
OpenStack.__init__(self, x, y, game, **cap)
def clickHandler(self, event):
if self.cards and not self.cards[-1].face_up:
return self.game.dealCards(sound=True)
return OpenStack.clickHandler(self, event)
def clickHandler(self, event):
return OpenStack.clickHandler(self, event)
def clickHandler(self, event):
if self._dropKingClickHandler(event):
return 1
return OpenStack.clickHandler(self, event)
def __init__(self, x, y, game):
OpenStack.__init__(self, x, y, game, max_accept=1, max_cards=2)
self.CARD_YOFFSET = 1
self.blockmap = []
def clickHandler(self, event):
if self.cards:
return OpenStack.clickHandler(self, event)
else:
return TalonStack.clickHandler(self, event)
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 __init__(self, x, y, game):
OpenStack.__init__(self, x, y, game, max_accept=1, max_cards=2)
self.CARD_YOFFSET = 1
self.blockmap = []
def copyModel(self, clone):
OpenStack.copyModel(self, clone)
clone.blockmap = self.blockmap
def clickHandler(self, event):
if self._dropKingClickHandler(event):
return 1
return OpenStack.clickHandler(self, event)
def clickHandler(self, event):
return OpenStack.clickHandler(self, event)
def canFlipCard(self):
if not OpenStack.canFlipCard(self):
return False
i = list(self.game.s.reserves).index(self)
return len(self.game.s.foundations[i].cards) == 13
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return 0
return self.game.cardsMatch(self.cards[0], cards[-1])
def __init__(self, x, y, game, suit=ANY_SUIT, **cap):
kwdefault(cap, max_move=0, max_accept=0, max_cards=game.NCARDS)
OpenStack.__init__(self, x, y, game, **cap)
def __init__(self, x, y, game, base_rank, yoffset, **cap):
kwdefault(cap, dir=3, max_move=99, max_cards=4, max_accept=1,
base_rank=base_rank)
OpenStack.__init__(self, x, y, game, **cap)
self.CARD_YOFFSET = yoffset
def __init__(self, x, y, game, yoffset, **cap):
kwdefault(cap, max_move=UNLIMITED_MOVES, max_cards=UNLIMITED_CARDS,
max_accept=UNLIMITED_ACCEPTS, base_rank=0, dir=-1)
OpenStack.__init__(self, x, y, game, **cap)
self.CARD_YOFFSET = yoffset
def __init__(self, x, y, game, **cap):
kwdefault(cap, max_cards=1, max_accept=1, base_rank=ANY_RANK)
OpenStack.__init__(self, x, y, game, **cap)
def copyModel(self, clone):
OpenStack.copyModel(self, clone)
clone.blockmap = self.blockmap
def __init__(self, x, y, game):
OpenStack.__init__(self, x, y, game, max_move=0, max_accept=1)
self.CARD_YOFFSET = 1
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
if to_stack in self.game.s.rows and not to_stack.cards:
return OpenStack.moveMove(self, ncards, to_stack, frames, shadow)
return Giza_Reserve.moveMove(self, ncards, to_stack, frames, shadow)
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return False
return self.cards[-1].rank + cards[0].rank == 12
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
if to_stack in self.game.s.rows and not to_stack.cards:
return OpenStack.moveMove(self, ncards, to_stack, frames, shadow)
return Giza_Reserve.moveMove(self, ncards, to_stack, frames, shadow)
def acceptsCards(self, from_stack, cards):
if not OpenStack.acceptsCards(self, from_stack, cards):
return 0
if not self.cards:
return from_stack in self.game.s.foundations and cards[0].suit == 4
return from_stack in self.game.s.rows
