def defaultText(self, layout_stack):
if self.canvas.preview > 1:
return None
##print layout_stack, layout_stack.text_args
if layout_stack is None or not layout_stack.text_args:
return None
layout_stack.text_args["font"] = self.game.app.getFont("canvas_default")
t = MfxCanvasText(self.game.canvas, **layout_stack.text_args)
t.text_format = layout_stack.text_format
return t
def createGame(self):
# Canfield.createGame(self, rows=8, max_rounds=3, num_deal=1)
# create layout
lay, s = Layout(self), self.s
# set window
self.setSize(lay.XM + 9 * lay.XS + lay.XM, lay.YM + 4 * lay.YS)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=3, num_deal=1)
lay.createText(s.talon, "s")
lay.createRoundText(s.talon, 'ne', dx=lay.XS)
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, "s")
for i in range(4):
x = lay.XM + (i + 3) * lay.XS
s.foundations.append(
self.Foundation_Class(x, y, self, i, mod=13, max_move=0))
tx, ty, ta, tf = lay.getTextAttr(None, "se")
tx, ty = x + tx + lay.XM, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
ry = lay.YM + 2 * lay.YS
for i in range(8):
x = lay.XM + (i + (i >= 4)) * lay.XS
y = ry - (0.2, 0.4, 0.6, 0.4, 0.4, 0.6, 0.4, 0.2)[i] * lay.CH
s.rows.append(self.RowStack_Class(x, y, self))
x, y = lay.XM + 4 * lay.XS, ry
s.reserves.append(self.ReserveStack_Class(x, y, self))
# s.reserves[0].CARD_YOFFSET = 0
lay.createText(s.reserves[0], "s")
# define stack-groups
lay.defaultStackGroups()
def createGame(self, cells=1, reserves=2, texts=True):
# create layout
l, s = Layout(self), self.s
# set window
# set size so that at least 2/3 of a card is visible with 15 cards
h = l.CH*2/3 + (15-1)*l.YOFFSET
h = l.YS + max(h, 3*l.YS)
max_rows = 8+max(cells, reserves)
self.setSize(l.XM + 2*l.XM + max_rows*l.XS, l.YM + h)
x1 = l.XM + 8*l.XS + 2*l.XM
# create stacks
y = l.YM + l.YS
for j in range(8):
x = l.XM + j*l.XS
s.rows.append(self.RowStack_Class(x, y, self))
for j in range(reserves):
x = x1 + j*l.XS
s.rows.append(self.ReserveStack_Class(x, y, self))
self.setRegion(s.rows, (-999, y - l.CH/2, 999999, 999999))
y = l.YM
x = x1+(max(cells, reserves)-cells)*l.XS/2
for i in range(cells):
s.reserves.append(self.FreeCell_Class(x, y, self))
x += l.XS
# foundations
x = l.XM + 2*l.XS
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, i))
x = x + l.XS
if texts:
tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "se")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=font)
# talon
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# define stack-groups
l.defaultStackGroups()
def createGame(self):
playcards = 6
l, s = Layout(self), self.s
self.setSize(
l.XM + 10 * l.XS,
l.YM + 3 * l.YS + 2 * playcards * l.YOFFSET + l.TEXT_HEIGHT)
x, y = l.XM, l.YM
s.talon = SlyFox_Talon(x, y, self)
s.waste = s.talon
l.createText(s.talon, 'ne')
tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
font = self.app.getFont("canvas_default")
self.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x += 2 * l.XS
for i in range(4):
s.foundations.append(SlyFox_Foundation(x, y, self, suit=i))
s.foundations.append(
SlyFox_Foundation(x + 4 * l.XS,
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):
stack = SlyFox_RowStack(x, y, self, max_cards=UNLIMITED_CARDS)
s.rows.append(stack)
stack.CARD_YOFFSET = l.YOFFSET
x += l.XS
y += l.YS + playcards * l.YOFFSET
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# game extras
self.other_stack = None
self.closed_cards = -1
self.score = 0
# create text
x, y = l.XM, self.ROWS * l.YS
if self.preview <= 1:
self.texts.score = MfxCanvasText(
self.canvas,
x,
y,
anchor="sw",
font=self.app.getFont("canvas_large"))
x = self.texts.score.bbox()[1][0] + 16
# set window
w = max(2 * l.XS, x)
self.setSize(l.XM + w + self.COLUMNS * l.XS, l.YM + self.ROWS * l.YS)
# create stacks
for i in range(self.ROWS):
for j in range(self.COLUMNS):
x, y = l.XM + w + j * l.XS, l.YM + i * l.YS
s.rows.append(
Memory_RowStack(x,
y,
self,
max_move=0,
max_accept=0,
max_cards=1))
x, y = l.XM, l.YM
s.talon = InitialDealTalonStack(x, y, self)
l.createText(s.talon, anchor="n", text_format="%D")
s.internals.append(InvisibleStack(self))
# define stack-groups
l.defaultStackGroups()
def createRoundText(self, stack, anchor, dx=0, dy=0):
if self.canvas.preview > 1:
return
assert stack.texts.rounds is None
delta_x, delta_y = 0, 0
if anchor == 'nnn':
anchor = 'nn'
delta_y = -self.TEXT_MARGIN
elif anchor == 'sss':
anchor = 'ss'
delta_y = self.TEXT_MARGIN
tx, ty, ta, tf = self.getTextAttr(stack, anchor)
tx += delta_x + dx
ty += delta_y + dy
font = self.game.app.getFont("canvas_default")
stack.texts.rounds = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
def createGame(self, rows=8, reserves=4, playcards=15):
decks = self.gameinfo.decks
l, s = Layout(self), self.s
self.setSize(l.XM + rows * l.XS,
l.YM + 2 * l.YS + playcards * l.YOFFSET)
x, y = l.XM, l.YM
for i in range(reserves):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x = self.width - 2 * l.XS
s.foundations.append(
FourByFour_Foundation(x,
y,
self,
suit=ANY_SUIT,
base_rank=ACE,
max_cards=52 * decks,
max_accept=1,
max_move=0))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'ne')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = l.XM, l.YM + l.YS
for i in range(rows):
s.rows.append(AC_RowStack(x, y, self))
x += l.XS
x, y = l.XM, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 13 * l.XS, l.YM + 7 * l.YS)
self.base_rank = ANY_RANK
self.draws_with_open = 0
x, y = l.XM + 2.5 * l.XS, l.YM
for i in range(8):
s.foundations.append(
StepUp_Foundation(x,
y,
self,
suit=i % 4,
mod=13,
base_rank=ANY_RANK))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(s.foundations[0], "sw")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = l.XM, l.YM + l.YS
for i in range(13):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
x, y = l.XM + 2 * l.XS, l.YM + 2 * l.YS
for i in range(9):
s.rows.append(StepUp_RowStack(x, y, self, max_move=1, mod=13))
x += l.XS
x, y = l.XM, l.YM + 2.5 * l.YS
s.talon = StepUp_Talon(x, y, self, max_rounds=1)
l.createText(s.talon, 'se')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'se')
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 7 * l.XS, l.YM + 2 * l.YS + 20 * 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')
x += 3.5 * l.XS
s.foundations.append(
FourByFour_Foundation(x,
y,
self,
suit=ANY_SUIT,
base_rank=ANY_RANK,
max_cards=52,
max_accept=1,
max_move=0,
mod=13))
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, 'ne')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = l.XM + 3 * l.XS, l.YM + l.YS
for i in range(4):
stack = UD_RK_RowStack(x, y, self, mod=13)
stack.getBottomImage = stack._getReserveBottomImage
s.rows.append(stack)
x += l.XS
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + 7*l.XS, l.YM + l.TEXT_HEIGHT + 5*l.YS)
# create stacks
x, y = l.XM, l.YM
s.talon = Glenwood_Talon(x, y, self, max_rounds=2, num_deal=1)
l.createText(s.talon, "s")
l.createRoundText(s.talon, 'ne', dx=l.XS)
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, "s")
x += 2*l.XS
for i in range(4):
s.foundations.append(self.Foundation_Class(x, y, self, i, dir=1,
mod=13, base_rank=ANY_RANK, max_move=0))
x += l.XS
tx, ty, ta, tf = l.getTextAttr(None, "ss")
tx, ty = x - l.XS + tx, y + ty
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
for i in range(4):
x = l.XM + (i+3)*l.XS
y = l.YM+l.TEXT_HEIGHT+l.YS
s.rows.append(self.RowStack_Class(x, y, self, mod=13))
for i in range(4):
x = l.XM
y = l.YM+l.TEXT_HEIGHT+(i+1)*l.YS
stack = self.ReserveStack_Class(x, y, self)
s.reserves.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
# define stack-groups
l.defaultStackGroups()
def createGame(self, rows=7):
self.used = False
# create layout
l, s = Layout(self), self.s
# set window
# (piles up to 4 cards are playable in default window size)
h = max(2 * l.YS, (4 * l.YOFFSET) + l.TEXT_HEIGHT)
self.setSize(l.XM + (1.5 + rows) * l.XS + l.XM, l.YM + h)
# create stacks
x0 = l.XM + (l.XS * 1.5)
x = x0
y = l.YM + l.TEXT_HEIGHT
font = self.app.getFont("canvas_default")
for i in range(rows):
stack = Ladybug_RowStack(x, y, self, max_cards=4,
max_accept=1, max_move=0)
if self.preview <= 1:
tx, ty, ta, tf = l.getTextAttr(stack, anchor="n")
stack.texts.misc = MfxCanvasText(self.canvas,
tx, ty,
anchor=ta,
font=font)
s.rows.append(stack)
x = x + l.XS
self.setRegion(s.rows, (x0-l.XS//2, y-l.CH//2, 999999, 999999))
x, y = l.XM, l.YM
s.talon = Ladybug_Talon(x, y, self, max_rounds=-1, num_deal=3)
l.createText(s.talon, 'ne')
y = y + l.YS
s.waste = Ladybug_Waste(x, y, self)
l.createText(s.waste, 'ne')
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self):
l, s = Layout(self), self.s
self.setSize(l.XM + 9 * l.XS, l.YM + 4 * l.YS)
x, y = l.XM, l.YM
s.talon = SlyFox_Talon(x, y, self)
s.waste = s.talon
l.createText(s.talon, 'ne')
tx, ty, ta, tf = l.getTextAttr(s.talon, "ss")
font = self.app.getFont("canvas_default")
self.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
y = l.YM
for i in range(4):
x = l.XM + 1.5 * l.XS
for j in range(5):
stack = SlyFox_RowStack(x, y, self, max_cards=UNLIMITED_CARDS)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
x += l.XS
y += l.YS
x, y = self.width - 2 * l.XS, l.YM
for i in range(4):
s.foundations.append(SlyFox_Foundation(x, y, self, suit=i))
s.foundations.append(
SlyFox_Foundation(x + l.XS,
y,
self,
suit=i,
base_rank=KING,
dir=-1))
y += l.YS
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self, card_x_space=4), self.s
# game extras
self.other_stack = None
self.closed_cards = -1
self.score = 0
# set window
self.setSize(l.XM + self.COLUMNS * l.XS, l.YM + (self.ROWS + 1) * l.YS)
# create stacks
for i in range(self.ROWS):
for j in range(self.COLUMNS):
x, y = l.XM + j * l.XS, l.YM + i * l.YS
s.rows.append(
Concentration_RowStack(x,
y,
self,
max_move=0,
max_accept=0,
max_cards=1))
x, y = l.XM + self.COLUMNS * l.XS / 2, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
l.createText(s.talon, dx=-10, anchor="sw", text_format="%D")
# create text
x, y = l.XM, self.height - l.YM
if self.preview <= 1:
self.texts.score = MfxCanvasText(
self.canvas,
x,
y,
anchor="sw",
font=self.app.getFont("canvas_large"))
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# (set piles so that at least 2/3 of a card is visible with 12 cards)
h = max(2 * l.YS, (12 - 1) * l.YOFFSET + l.CH * 2 / 3)
self.setSize(10 * l.XS + l.XM, h + l.YM + h)
# create stacks
##center, c1, c2 = self.height / 2, h, self.height - h
center = self.height / 2
c1, c2 = center - l.TEXT_HEIGHT / 2, center + l.TEXT_HEIGHT / 2
x, y = l.XM, c1 - l.CH
for i in range(8):
s.rows.append(Matriarchy_UpRowStack(x, y, self, i / 2))
x = x + l.XS
x, y = l.XM, c2
for i in range(8):
s.rows.append(Matriarchy_DownRowStack(x, y, self, i / 2))
x = x + l.XS
x, y = x + l.XS / 2, c1 - l.CH / 2 - l.CH
tx = x + l.CW / 2
s.waste = Matriarchy_Waste(x, y, self)
l.createText(s.waste, "s")
y = c2 + l.CH / 2
s.talon = Matriarchy_Talon(x, y, self, max_rounds=VARIABLE_REDEALS)
l.createText(s.talon, "n")
l.createRoundText(s.talon, 'ss')
s.talon.texts.misc = MfxCanvasText(
self.canvas,
tx,
center,
anchor="center",
font=self.app.getFont("canvas_large"))
# define stack-groups
l.defaultStackGroups()
def createGame(self):
layout, s = Layout(self), self.s
self.rank = -1
self.deadDeals = 1
self.max_rounds = VARIABLE_REDEALS
self.setSize(layout.XM + 4 * layout.XS, layout.YM + 2 * layout.YS)
x, y = layout.XM + 3 * layout.XS // 2, layout.YM
stack = HitOrMiss_Foundation(x,
y,
self,
ANY_SUIT,
dir=0,
mod=13,
max_move=0,
max_cards=52)
s.foundations.append(stack)
layout.createText(stack, 'ne')
x, y = layout.XM + layout.XS, layout.YM + layout.YS
s.talon = HitOrMiss_Talon(x,
y,
self,
max_rounds=VARIABLE_REDEALS,
num_deal=1)
layout.createText(s.talon, 'nw')
x += layout.XS
s.waste = HitOrMiss_Waste(x, y, self)
layout.createText(s.waste, 'ne')
x += layout.XS * 1.1
y = layout.YM + 1.4 * layout.YS
if self.preview <= 1:
self.texts.rank = \
MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text=_(""))
# define stack-groups
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
pad = 1
if self.Comment:
pad = 5
# set window
xx, yy = 9, 6
w, h = l.XM + xx * l.XS, (l.YM * pad) + yy * l.YS
self.setSize(w, h)
# create stacks
for i in range(yy):
for j in range(xx):
n = j+xx*i
if n < 1:
continue
if n > 52:
break
k = j
if i % 2:
k = xx-j-1
x, y = l.XM + k*l.XS, (l.YM * pad) + i * l.YS
s.rows.append(self.RowStack_Class(x, y, self))
s.talon = PushPin_Talon(l.XM, l.YM * pad, self)
if self.Comment:
self.texts.base_rank = \
MfxCanvasText(self.canvas, l.XM, l.YM, anchor="nw",
font=self.app.getFont("canvas_default"))
s.foundations.append(PushPin_Foundation(l.XM, h-l.YS, self,
suit=ANY_SUIT, dir=0, base_rank=ANY_RANK,
max_accept=0, max_move=0, max_cards=52))
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self, rows=3, cols=3, reserves=3, texts=False):
layout, s = Layout(self), self.s
self.setSize(
layout.XM+(cols+2)*layout.XS,
layout.YM+(rows+1.5)*layout.YS)
x, y = self.width-layout.XS, layout.YM
s.talon = TalonStack(x, y, self)
layout.createText(s.talon, 's')
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')
y = layout.YM
for i in range(rows):
x = layout.XM
for j in range(cols):
s.rows.append(self.RowStack_Class(x, y, self, max_accept=1))
x += layout.XS
y += layout.YS
x, y = layout.XM, self.height-layout.YS
for i in range(reserves):
stack = self.Reserve_Class(x, y, self)
s.reserves.append(stack)
stack.CARD_XOFFSET = layout.XOFFSET # for fifteens
x += layout.XS
if texts:
stack = s.reserves[0]
tx, ty, ta, tf = layout.getTextAttr(stack, "n")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
layout.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
w = l.XS
self.setSize(l.XM + w + 4*l.XS + w + l.XS, l.YM + 4*l.YS)
# create stacks
stackNum = 0
font = self.app.getFont("canvas_default")
for i in range(4):
for j in range(4):
x, y = l.XM + w + j*l.XS, l.YM + i*l.YS
stack = self.RowStack_Class(x, y, self)
if self.preview <= 1:
stack.texts.misc = MfxCanvasText(self.canvas,
x + l.CW // 2,
y + l.CH // 2,
anchor="center",
font=font)
if stackNum in (0, 3, 12, 15):
stack.texts.misc.config(text="K")
elif stackNum in (1, 2, 13, 14):
stack.texts.misc.config(text="Q")
elif stackNum in (4, 7, 8, 11):
stack.texts.misc.config(text="J")
s.rows.append(stack)
stackNum += 1
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, 's')
x, y = l.XM + w + 4*l.XS + w, l.YM
s.foundations.append(Camelot_Foundation(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], 's')
# define stack-groups
l.defaultStackGroups()
return l
def createGame(self):
lay = Numerica.createGame(
self, max_rounds=3, waste_max_cards=UNLIMITED_CARDS)
self.year = str(time.localtime()[0])
i = 0
font = self.app.getFont("canvas_default")
for s in self.s.foundations:
d = int(self.year[i])
if d == 0:
d = JACK
s.cap.base_rank = d
if self.preview <= 1:
label = RANKS[d][0]
if label == "1":
label = "10"
s.texts.misc = MfxCanvasText(self.canvas,
s.x + lay.CW // 2,
s.y + lay.CH // 2,
anchor="center",
font=font)
s.texts.misc.config(text=label)
i += 1
lay.createRoundText(self.s.talon, 'nn')
def createGame(self):
rows = 8
layout, s = Layout(self), self.s
self.setSize(
layout.XM+rows*layout.XS, layout.YM+2*layout.YS+20*layout.YOFFSET)
x, y = layout.XM, layout.YM
for i in range(rows):
s.rows.append(RK_RowStack(x, y, self))
x += layout.XS
x, y = layout.XM+(rows-1)*layout.XS//2, self.height-layout.YS
s.foundations.append(Waterfall_Foundation(x, y, self, suit=ANY_SUIT,
max_cards=104))
stack = s.foundations[0]
tx, ty, ta, tf = layout.getTextAttr(stack, 'se')
font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
anchor=ta, font=font)
x, y = self.width-layout.XS, self.height-layout.YS
s.talon = DealRowTalonStack(x, y, self)
layout.createText(s.talon, 'sw')
layout.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# Set window size
self.setSize(l.XM + l.XS * 10.5, l.YM + l.YS * 5.5)
# Create clock
xoffset = (1, 2, 2.5, 2, 1, 0, -1, -2, -2.5, -2, -1, 0)
yoffset = (0.25, 0.75, 1.9, 3, 3.5, 3.75, 3.5, 3, 1.9, 0.75, 0.25, 0)
x = l.XM + l.XS * 7
y = l.CH / 3
for i in range(12):
x0 = x + xoffset[i] * l.XS
y0 = y + yoffset[i] * l.YS
stack = FlowerClock_Foundation(x0, y0, self, ANY_SUIT, base_rank=3)
s.foundations.append(stack)
t = MfxCanvasText(self.canvas, x0 + l.CW / 2, y0 + l.YS,
anchor="center", font=font,
text=self.SUITS[i])
stack.texts.misc = t
# Create row stacks
for j in range(2):
x, y = l.XM, l.YM + l.YS * j * 2.7
for i in range(4):
s.rows.append(FlowerClock_RowStack(x, y, self, yoffset=l.CH/4,
max_cards=8, max_accept=8))
x = x + l.XS
self.setRegion(s.rows, (0, 0, l.XS * 4, 999999))
# Create talon
s.talon = InitialDealTalonStack(
self.width - l.XS, self.height - l.YS, self)
# Define stack groups
l.defaultStackGroups()
def createGame(self):
l, s = Layout(self), self.s
font = self.app.getFont("canvas_default")
# Set window size
w, h = l.XM + l.XS * 15, l.YM + l.YS * 6.2
self.setSize(w, h)
# Create foundations
x, y = (l.XM, l.XM, w - l.XS, w - l.XS), (l.YM, h / 2, l.YM, h / 2)
for i in range(4):
stack = GreatWall_FoundationStack(x[i], y[i] + l.YM, self, -1,
base_rank=i)
s.foundations.append(stack)
stack.texts.misc = MfxCanvasText(self.canvas,
x[i] + l.CW / 2, y[i],
anchor="center", font=font)
# Create row stacks
x = l.XM + l.XS * 1.5
y = l.YM
for i in range(12):
s.rows.append(GreatWall_RowStack(x, y, self, yoffset=l.CH/4,
max_cards=26, max_accept=26))
x = x + l.XS
self.setRegion(
s.rows, (l.XM + l.XS * 1.25, -999, self.width - l.XS * 1.25,
999999))
# Create talon
x = self.width / 2 - l.CW / 2
y = self.height - l.YS * 1.2
s.talon = InitialDealTalonStack(x, y, self)
# Define stack groups
l.defaultStackGroups()
def createGame(self,
rows=4,
max_rounds=-1,
num_deal=3,
text=True,
round_text=False):
# create layout
lay, s = Layout(self), self.s
decks = self.gameinfo.decks
# set window
if self.INITIAL_RESERVE_FACEUP == 1:
yoffset = lay.YOFFSET # min(lay.YOFFSET, 14)
else:
yoffset = 10
if self.INITIAL_RESERVE_CARDS > 30:
yoffset = 5
# (piles up to 20 cards are playable in default window size)
h = max(3 * lay.YS, lay.YS + self.INITIAL_RESERVE_CARDS * yoffset)
if round_text:
h += lay.TEXT_HEIGHT
self.setSize(lay.XM + (2 + max(rows, 4 * decks)) * lay.XS + lay.XM,
lay.YM + lay.YS + lay.TEXT_HEIGHT + h)
# extra settings
self.base_card = None
# create stacks
x, y = lay.XM, lay.YM
s.talon = self.Talon_Class(x,
y,
self,
max_rounds=max_rounds,
num_deal=num_deal)
lay.createText(s.talon, "s")
if round_text:
lay.createRoundText(s.talon, 'sss')
x += lay.XS
s.waste = WasteStack(x, y, self)
lay.createText(s.waste, "s")
x += lay.XM
y = lay.YM
for i in range(4):
for j in range(decks):
x += lay.XS
s.foundations.append(
self.Foundation_Class(x, y, self, i, mod=13, max_move=0))
if text:
if rows > 4 * decks:
tx, ty, ta, tf = lay.getTextAttr(None, "se")
tx, ty = x + tx + lay.XM, y + ty
else:
tx, ty, ta, tf = lay.getTextAttr(None, "ss")
tx, ty = x + 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
if round_text:
y += lay.TEXT_HEIGHT
s.reserves.append(self.ReserveStack_Class(x, y, self))
s.reserves[0].CARD_YOFFSET = yoffset
x, y = lay.XM + 2 * lay.XS + lay.XM, lay.YM + lay.YS
if text:
y += lay.TEXT_HEIGHT
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self))
x += lay.XS
# define stack-groups
lay.defaultStackGroups()
def createGame(self):
cols, rows = self.L
assert cols * rows == self.NCARDS
# start layout
l, s = Layout(self), self.s
# dx, dy = 3, -3
cs = self.app.cardset
if cs.version >= 6:
dx = l.XOFFSET
dy = -l.YOFFSET
d_x = cs.SHADOW_XOFFSET
d_y = cs.SHADOW_YOFFSET
self._delta_x, self._delta_y = dx, -dy
else:
dx = 3
dy = -3
d_x = 0
d_y = 0
self._delta_x, self._delta_y = 0, 0
font = self.app.getFont("canvas_default")
# width of self.texts.info
# ti_width = Font(self.canvas, font).measure(_('Remaining'))
ti_width = 80
# set window size
dxx, dyy = abs(dx), abs(dy)
cardw, cardh = l.CW - d_x, l.CH - d_y
w = l.XM + dxx + cols * cardw + d_x + l.XM + ti_width + l.XM
h = l.YM + dyy + rows * cardh + d_y + l.YM
self.setSize(w, h)
self.XMARGIN = l.XM + dxx
self.YMARGIN = l.YM + dyy
# set game extras
self.check_dist = l.CW * l.CW + l.CH * l.CH # see _getClosestStack()
#
self.cols = [[] for i in xrange(cols)]
cl = range(cols)
if dx > 0:
cl.reverse()
for col in cl:
for row in xrange(rows):
x = l.XM + dxx + col * cardw
y = l.YM + dyy + row * cardh
stack = self.RowStack_Class(x, y, self)
stack.CARD_XOFFSET = 0
stack.CARD_YOFFSET = 0
stack.coln, stack.rown = col, row
s.rows.append(stack)
self.cols[col].append(stack)
# from pprint import pprint
# pprint(self.cols)
# create other stacks
y = l.YM + dyy
s.foundations.append(
Shisen_Foundation(-l.XS - self.canvas.xmargin, y, self))
self.texts.info = MfxCanvasText(self.canvas,
self.width - l.XM - ti_width,
y,
anchor="nw",
font=font)
# the Talon is invisble
s.talon = InitialDealTalonStack(-l.XS - self.canvas.xmargin,
self.height - dyy, self)
# Define stack groups
l.defaultStackGroups()
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):
tiles, max_tl, max_tx, max_ty = self.getTiles()
# start layout
l, s = Layout(self), self.s
show_removed = self.app.opt.mahjongg_show_removed
# dx, dy = 2, -2
# dx, dy = 3, -3
cs = self.app.cardset
if cs.version >= 6:
dx = l.XOFFSET
dy = -l.YOFFSET
d_x = cs.SHADOW_XOFFSET
d_y = cs.SHADOW_YOFFSET
if self.preview:
# Fixme
dx, dy, d_x, d_y = dx // 2, dy // 2, d_x // 2, d_y // 2
self._delta_x, self._delta_y = dx, -dy
else:
dx = 3
dy = -3
d_x = 0
d_y = 0
self._delta_x, self._delta_y = 0, 0
# print dx, dy, d_x, d_y, cs.version
font = self.app.getFont("canvas_default")
# width of self.texts.info
# ti_width = Font(self.canvas, font).measure(_('Remaining'))
ti_width = 80
# set window size
dxx, dyy = abs(dx) * (max_tl + 1), abs(dy) * (max_tl + 1)
# foundations dxx dyy
if self.NCARDS > 144:
fdxx = abs(dx) * 8
fdyy = abs(dy) * 8
else:
fdxx = abs(dx) * 4
fdyy = abs(dy) * 4
cardw, cardh = l.CW - d_x, l.CH - d_y
if show_removed:
left_margin = l.XM + 4 * cardw + fdxx + d_x + l.XM
else:
left_margin = l.XM
tableau_width = (max_tx + 2) * cardw // 2 + dxx + d_x
right_margin = l.XM + ti_width + l.XM
w = left_margin + tableau_width + right_margin
h = l.YM + dyy + (max_ty + 2) * cardh // 2 + d_y + l.YM
if show_removed:
h = max(h, l.YM + fdyy + cardh * 9 + d_y + l.YM)
self.setSize(w, h)
# set game extras
self.check_dist = l.CW * l.CW + l.CH * l.CH # see _getClosestStack()
# sort tiles (for 3D)
tiles.sort(key=lambda x: (x[0], x[2] - x[1]))
# create a row stack for each tile and compute the tilemap
tilemap = {}
x0 = left_margin
y0 = l.YM + dyy
for level, tx, ty in tiles:
# print level, tx, ty
x = x0 + (tx * cardw) // 2 + level * dx
y = y0 + (ty * cardh) // 2 + level * dy
stack = self.RowStack_Class(x, y, self)
# stack.G = (level, tx, ty)
stack.CARD_XOFFSET = dx
stack.CARD_YOFFSET = dy
s.rows.append(stack)
# tilemap - each tile covers 4 positions
tilemap[(level, tx, ty)] = stack
tilemap[(level, tx + 1, ty)] = stack
tilemap[(level, tx, ty + 1)] = stack
tilemap[(level, tx + 1, ty + 1)] = stack
# compute blockmap
for stack in s.rows:
level, tx, ty = tiles[stack.id]
above, below, left, right = {}, {}, {}, {}
# above blockers
for tl in range(level + 1, level + 2):
above[tilemap.get((tl, tx, ty))] = 1
above[tilemap.get((tl, tx + 1, ty))] = 1
above[tilemap.get((tl, tx, ty + 1))] = 1
above[tilemap.get((tl, tx + 1, ty + 1))] = 1
#
for tl in range(level):
below[tilemap.get((tl, tx, ty))] = 1
below[tilemap.get((tl, tx + 1, ty))] = 1
below[tilemap.get((tl, tx, ty + 1))] = 1
below[tilemap.get((tl, tx + 1, ty + 1))] = 1
# left blockers
left[tilemap.get((level, tx - 1, ty))] = 1
left[tilemap.get((level, tx - 1, ty + 1))] = 1
# right blockers
right[tilemap.get((level, tx + 2, ty))] = 1
right[tilemap.get((level, tx + 2, ty + 1))] = 1
# up blockers
# up[tilemap.get((level, tx, ty-1))] = 1
# up[tilemap.get((level, tx+1, ty-1))] = 1
# bottom blockers
# bottom[tilemap.get((level, tx, ty+2))] = 1
# bottom[tilemap.get((level, tx+1, ty+2))] = 1
# sanity check - assert that there are no overlapping tiles
assert tilemap.get((level, tx, ty)) is stack
assert tilemap.get((level, tx + 1, ty)) is stack
assert tilemap.get((level, tx, ty + 1)) is stack
assert tilemap.get((level, tx + 1, ty + 1)) is stack
#
above = tuple([_f for _f in above.keys() if _f])
below = tuple([_f for _f in below.keys() if _f])
left = tuple([_f for _f in left.keys() if _f])
right = tuple([_f for _f in right.keys() if _f])
# up = tuple(filter(None, up.keys()))
# bottom = tuple(filter(None, bottom.keys()))
# assemble
stack.blockmap = Struct(
above=above,
below=below,
left=left,
right=right,
# up=up,
# bottom=bottom,
all_left=None,
all_right=None,
)
def get_all_left(s):
if s.blockmap.all_left is None:
s.blockmap.all_left = {}
for t in s.blockmap.left:
if t.blockmap.all_left is None:
get_all_left(t)
s.blockmap.all_left.update(t.blockmap.all_left)
s.blockmap.all_left[t] = 1
def get_all_right(s):
if s.blockmap.all_right is None:
s.blockmap.all_right = {}
for t in s.blockmap.right:
if t.blockmap.all_right is None:
get_all_right(t)
s.blockmap.all_right.update(t.blockmap.all_right)
s.blockmap.all_right[t] = 1
for r in s.rows:
get_all_left(r)
get_all_right(r)
for r in s.rows:
r.blockmap.all_left = tuple(r.blockmap.all_left.keys())
r.blockmap.all_right = tuple(r.blockmap.all_right.keys())
# create other stacks
for i in range(4):
for j in range(9):
if show_removed:
x = l.XM + i * cardw
y = l.YM + fdyy + j * cardh
else:
if TOOLKIT == 'tk':
x = -l.XS - self.canvas.xmargin
y = l.YM + dyy
elif TOOLKIT == 'gtk':
# FIXME
x = self.width - l.XS
y = self.height - l.YS
stack = Mahjongg_Foundation(x, y, self)
if show_removed:
stack.CARD_XOFFSET = dx
stack.CARD_YOFFSET = dy
s.foundations.append(stack)
self.texts.info = MfxCanvasText(self.canvas,
self.width - l.XM - ti_width,
l.YM + dyy,
anchor="nw",
font=font)
# the Talon is invisble
s.talon = InitialDealTalonStack(-l.XS - self.canvas.xmargin,
self.height - dyy, self)
# Define stack groups
l.defaultStackGroups()
def createGame(self):
lay = Fortress.createGame(self)
tx, ty, ta, tf = lay.getTextAttr(self.s.foundations[-1], "e")
font = self.app.getFont("canvas_default")
self.texts.info = MfxCanvasText(
self.canvas, tx + lay.XM, ty, anchor=ta, font=font)
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):
# create layout
l, s = Layout(self), self.s
# create texts 1)
ta = "ss"
x, y = l.XM, l.YM + 2*l.YS
if self.preview <= 1:
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text=_('''\
Royal Flush
Straight Flush
Four of a Kind
Full House
Flush
Straight
Three of a Kind
Two Pair
One Pair'''))
self.texts.list.append(t)
bb = t.bbox()
x = bb[1][0] + 16
h = bb[1][1] - bb[0][1]
if h >= 2*l.YS:
ta = "e"
t.move(0, -l.YS)
y = y - l.YS
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="100\n75\n50\n25\n20\n15\n10\n5\n2")
self.texts.list.append(t)
x = t.bbox()[1][0] + 16
self.texts.misc = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="0\n"*8+"0")
x = self.texts.misc.bbox()[1][0] + 32
# set window
w = max(2*l.XS, x)
self.setSize(l.XM + w + 5*l.XS + 50, l.YM + 5*l.YS + 30)
# create stacks
for i in range(5):
for j in range(5):
x, y = l.XM + w + j*l.XS, l.YM + i*l.YS
s.rows.append(self.RowStack_Class(x, y, self))
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, anchor=ta)
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
# create texts 2)
if self.preview <= 1:
for i in (4, 9, 14, 19, 24):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="e")
t = MfxCanvasText(self.canvas, tx+8, ty,
anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
for i in range(20, 25):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="ss")
t = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
self.texts.score = MfxCanvasText(self.canvas, l.XM, 5*l.YS, anchor="sw",
font=self.app.getFont("canvas_large"))
# define hands for scoring
r = s.rows
self.poker_hands = [
r[0:5], r[5:10], r[10:15], r[15:20], r[20:25],
(r[0], r[0+5], r[0+10], r[0+15], r[0+20]),
(r[1], r[1+5], r[1+10], r[1+15], r[1+20]),
(r[2], r[2+5], r[2+10], r[2+15], r[2+20]),
(r[3], r[3+5], r[3+10], r[3+15], r[3+20]),
(r[4], r[4+5], r[4+10], r[4+15], r[4+20]),
]
self.poker_hands = map(tuple, self.poker_hands)
# define stack-groups
l.defaultStackGroups()
return l
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 createGame(self):
l, s = Layout(self), self.s
h0 = l.YS + 4 * l.YOFFSET
self.setSize(l.XM + 11 * l.XS, l.YM + 2 * l.YS + 2 * h0)
self.base_rank = ANY_RANK
x, y = l.XM, l.YM
s.talon = GrandmammasPatience_Talon(x, y, self)
l.createText(s.talon, 'ne')
x, y = self.width - 4 * l.XS, l.YM
for i in range(4):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i,
dir=-1,
mod=13,
max_move=0,
base_rank=ANY_RANK))
x += l.XS
stack = s.foundations[0]
tx, ty, ta, tf = l.getTextAttr(stack, "sw")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
x, y = self.width - 4 * l.XS, self.height - l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i,
mod=13,
max_move=0,
base_rank=ANY_RANK))
x += l.XS
stack = s.foundations[4]
tx, ty, ta, tf = l.getTextAttr(stack, "sw")
font = self.app.getFont("canvas_default")
stack.texts.misc = MfxCanvasText(self.canvas,
tx,
ty,
anchor=ta,
font=font)
y = l.YM + l.YS
for i in range(2):
x = l.XM
for j in range(11):
s.rows.append(
GrandmammasPatience_RowStack(x,
y,
self,
max_accept=1,
max_cards=2))
x += l.XS
y += h0
x, y = l.XM, self.height - l.YS
for i in range(4):
s.reserves.append(ReserveStack(x, y, self))
x += l.XS
l.defaultStackGroups()
self.sg.dropstacks.append(s.talon)
def createGame(self):
# create layout
l, s = Layout(self), self.s
# create texts 1)
ta = "ss"
x, y = l.XM, l.YM + 2*l.YS
if self.preview <= 1:
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text=_('''\
Royal Flush
Straight Flush
Four of a Kind
Full House
Flush
Straight
Three of a Kind
Two Pair
One Pair'''))
self.texts.list.append(t)
bb = t.bbox()
x = bb[1][0] + 16
h = bb[1][1] - bb[0][1]
if h >= 2*l.YS:
ta = "e"
t.move(0, -l.YS)
y = y - l.YS
t = MfxCanvasText(self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="100\n75\n50\n25\n20\n15\n10\n5\n2")
self.texts.list.append(t)
x = t.bbox()[1][0] + 16
self.texts.misc = MfxCanvasText(
self.canvas, x, y, anchor="nw",
font=self.app.getFont("canvas_default"),
text="0\n"*8+"0")
x = self.texts.misc.bbox()[1][0] + 32
# set window
w = max(2*l.XS, x)
self.setSize(l.XM + w + 5*l.XS + 50, l.YM + 5*l.YS + 30)
# create stacks
for i in range(5):
for j in range(5):
x, y = l.XM + w + j*l.XS, l.YM + i*l.YS
s.rows.append(self.RowStack_Class(x, y, self))
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, anchor=ta)
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
# create texts 2)
if self.preview <= 1:
for i in (4, 9, 14, 19, 24):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="e")
t = MfxCanvasText(self.canvas, tx+8, ty,
anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
for i in range(20, 25):
tx, ty, ta, tf = l.getTextAttr(s.rows[i], anchor="ss")
t = MfxCanvasText(self.canvas, tx, ty, anchor=ta,
font=self.app.getFont("canvas_default"))
self.texts.list.append(t)
self.texts.score = MfxCanvasText(
self.canvas, l.XM, 5*l.YS, anchor="sw",
font=self.app.getFont("canvas_large"))
# define hands for scoring
r = s.rows
self.poker_hands = [
r[0:5], r[5:10], r[10:15], r[15:20], r[20:25],
(r[0], r[0+5], r[0+10], r[0+15], r[0+20]),
(r[1], r[1+5], r[1+10], r[1+15], r[1+20]),
(r[2], r[2+5], r[2+10], r[2+15], r[2+20]),
(r[3], r[3+5], r[3+10], r[3+15], r[3+20]),
(r[4], r[4+5], r[4+10], r[4+15], r[4+20]),
]
self.poker_hands = map(tuple, self.poker_hands)
# define stack-groups
l.defaultStackGroups()
return l
