def createGame(self):
l, s = Layout(self), self.s
playcards = 10
w0 = l.XS + (playcards - 1) * l.XOFFSET
w, h = l.XM + max(self.COLS * w0, 9 * l.XS), \
l.YM + (self.ROWS + 1) * l.YS + l.TEXT_HEIGHT
self.setSize(w, h)
x, y = l.XM, l.YM
s.talon = Crescent_Talon(x, y, self, max_rounds=4)
if self.SHOW_TALON_COUNT:
l.createText(s.talon, 'ne')
l.createRoundText(s.talon, 's')
x, y = w - 8 * l.XS, l.YM
for i in range(4):
s.foundations.append(SS_FoundationStack(x, y, self, suit=i))
x += l.XS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1))
x += l.XS
y = l.YM + l.YS + l.TEXT_HEIGHT
for i in range(self.ROWS):
x = l.XM
for j in range(self.COLS):
stack = UD_SS_RowStack(x, y, self, base_rank=NO_RANK, mod=13)
s.rows.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
x += w0
y += l.YS
self.s.internals.append(InvisibleStack(self))
self.s.internals.append(InvisibleStack(self))
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
self.setSize(l.XM + self.RSTEP*l.XS, l.YM + 5.5*l.YS)
# create stacks
for i in range(4):
x, y, = l.XM, l.YM + i*l.YS
for j in range(self.RSTEP):
s.rows.append(Spoilt_RowStack(x, y, self,
max_accept=1, max_cards=2, min_cards=1))
x += l.XS
x, y = self.width//2 - l.XS, self.height-l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'n')
x += l.XS
s.waste = Spoilt_Waste(x, y, self, max_cards=1)
# create an invisible stack
s.internals.append(InvisibleStack(self))
# define stack-groups
l.defaultStackGroups()
def createGame(self, round_text=True):
decks = self.gameinfo.decks
# create layout
l, s = Layout(self, card_x_space=4), self.s
# set window
w, h = l.XM + self.RSTEP*l.XS, l.YM + (4*decks)*l.YS
if round_text:
h += l.YS
self.setSize(w, h)
# create stacks
for k in range(decks):
for i in range(4):
x, y = l.XM, l.YM + (i+k*4)*l.YS
for j in range(self.RSTEP):
s.rows.append(self.RowStack_Class(x, y, self,
max_accept=1, max_cards=1))
x += l.XS
if round_text:
x, y = l.XM + (self.RSTEP-1)*l.XS//2, self.height-l.YS
s.talon = self.Talon_Class(x, y, self)
l.createRoundText(s.talon, 'se')
else:
# Talon is invisible
x, y = self.getInvisibleCoords()
s.talon = self.Talon_Class(x, y, self)
if self.RBASE:
# create an invisible stack to hold the four Aces
s.internals.append(InvisibleStack(self))
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
dx = l.XS + 3 * l.XOFFSET
w = max(5.25 * dx + l.XS, 5.5 * dx)
self.setSize(l.XM + w, l.YM + 4 * l.YS)
# create stacks
for xx, yy in (
(3.25, 0.15),
(4.25, 0.5),
(4.5, 1.5),
(4.25, 2.5),
(3.25, 2.85),
(2.25, 3),
(1.25, 2.85),
(0.25, 2.5),
(0, 1.5),
(0.25, 0.5),
(1.25, 0.15),
(2.25, 0),
):
x = l.XM + xx * dx
y = l.YM + yy * l.YS
stack = Clock_RowStack(x, y, self, max_move=0)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
stack.SHRINK_FACTOR = 1
s.rows.append(stack)
x, y = l.XM + 2.25 * dx, l.YM + 1.5 * l.YS
stack = Clock_RowStack(x, y, self, max_move=1)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
stack.SHRINK_FACTOR = 1
s.rows.append(stack)
x, y = self.width - l.XS, self.height - l.YS
s.talon = InitialDealTalonStack(x, y, self)
# create an invisible stacks
s.internals.append(InvisibleStack(self))
s.internals.append(InvisibleStack(self))
# default
l.defaultAll()
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, **layout):
# create layout
l, s = Layout(self), self.s
kwdefault(layout, rows=13, playcards=9)
self.Layout_Method(l, **layout)
self.setSize(l.size[0], l.size[1])
# create stacks
s.talon = self.Talon_Class(l.s.talon.x, l.s.talon.y, self)
for r in l.s.foundations:
s.foundations.append(
self.Foundation_Class(r.x, r.y, self, suit=r.suit))
for r in l.s.rows:
s.rows.append(self.RowStack_Class(r.x, r.y, self))
# default
self.s.internals.append(InvisibleStack(self))
l.defaultAll()
return l
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 createGame(self):
# create layout
l, s = Layout(self, card_x_space=4, card_y_space=4), self.s
# set window
self.setSize(l.XM + 9 * l.XS, l.YM + 6 * l.YS)
# create stacks
for i in range(6):
for j in range(9):
x, y, = l.XM + j * l.XS, l.YM + i * l.YS
s.rows.append(
Maze_RowStack(x, y, self, max_accept=1, max_cards=1))
# s.talon = InitialDealTalonStack(-2*l.XS, l.YM+5*l.YS/2, self)
s.talon = InitialDealTalonStack(self.width - l.XS + 1,
self.height - l.YS, self)
# create an invisble stack to hold the four Kings
s.internals.append(InvisibleStack(self))
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self, card_x_space=4), self.s
# set window
self.setSize(l.XM + 13 * l.XS, l.YM + 5 * l.YS)
# create stacks
for i in range(4):
for j in range(13):
x, y, = l.XM + j * l.XS, l.YM + i * l.YS
s.rows.append(
PasDeDeux_RowStack(x, y, self, max_accept=1, max_cards=2))
x, y = self.width - 2 * l.XS, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, "se")
l.createRoundText(s.talon, 'ne')
x -= l.XS
s.waste = PasDeDeux_Waste(x, y, self, max_move=0)
l.createText(s.waste, "sw")
s.internals.append(InvisibleStack(self)) # for _swapPairMove()
# define stack-groups
l.defaultStackGroups()
def createGame(self):
PictureGallery.createGame(self)
self.s.internals.append(InvisibleStack(self))
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):
l, s = Layout(self), self.s
self.setSize(l.XM + 9.5 * l.XS, l.YM + 5 * l.YS)
# internal stack (for swap)
s.internals.append(InvisibleStack(self))
x0, y0 = l.XM + 1.5 * l.XS, l.YM
# barriers
for xx, yy in (
(0, 2),
(7, 2),
(3.5, 0),
(3.5, 4),
):
x, y = x0 + xx * l.XS, y0 + yy * l.YS
s.rows.append(BasicRowStack(x, y, self, max_accept=0))
# northern hemisphere (red)
for xx, yy in (
(0.5, 1),
(1.5, 0.5),
(2.5, 0.3),
(4.5, 0.3),
(5.5, 0.5),
(6.5, 1),
):
x, y = x0 + xx * l.XS, y0 + yy * l.YS
stack = Hemispheres_RowStack(x,
y,
self,
base_color=RED,
max_move=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
# southern hemisphere (black)
for xx, yy in (
(6.5, 3),
(5.5, 3.5),
(4.5, 3.8),
(2.5, 3.8),
(1.5, 3.5),
(0.5, 3),
):
x, y = x0 + xx * l.XS, y0 + yy * l.YS
stack = Hemispheres_RowStack(x,
y,
self,
base_color=BLACK,
max_move=1,
dir=1)
stack.CARD_YOFFSET = 0
s.rows.append(stack)
# foundations
x, y = x0 + 2 * l.XS, y0 + 1.5 * l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x, y, self, suit=2 + i / 2, max_move=0))
x += l.XS
x, y = x0 + 2 * l.XS, y + l.YS
for i in range(4):
s.foundations.append(
SS_FoundationStack(x,
y,
self,
suit=i / 2,
max_move=0,
base_rank=KING,
dir=-1))
x += l.XS
# talon & waste
x, y = l.XM, l.YM
s.talon = WasteTalonStack(x, y, self, max_rounds=1)
l.createText(s.talon, 'ne')
y += l.YS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'ne')
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
dx = l.XS + 3*l.XOFFSET
w = max(5.25*dx + l.XS, 5.5*dx)
if self.HAS_WASTE:
w += (1.5 * l.XS)
self.setSize(l.XM + w, l.YM + 4*l.YS)
font = self.app.getFont("canvas_default")
# create stacks
row_rank = 0
for xx, yy in (
(3.25, 0.15),
(4.25, 0.5),
(4.5, 1.5),
(4.25, 2.5),
(3.25, 2.85),
(2.25, 3),
(1.25, 2.85),
(0.25, 2.5),
(0, 1.5),
(0.25, 0.5),
(1.25, 0.15),
(2.25, 0),
):
x = l.XM + xx*dx
y = l.YM + yy*l.YS
if self.HAS_WASTE:
x += (2 * l.XS)
stack = self.RowStack_Class(x, y, self, max_move=0,
base_rank=row_rank)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
stack.SHRINK_FACTOR = 1
s.rows.append(stack)
if self.preview <= 1:
label = RANKS[row_rank][0]
if label == "1":
label = "10"
stack.texts.misc = MfxCanvasText(self.canvas,
x + l.CW // 2,
y + l.CH // 2,
anchor="center",
font=font)
stack.texts.misc.config(text=label)
row_rank += 1
x, y = l.XM + 2.25*dx, l.YM + 1.5*l.YS
if self.HAS_WASTE:
x += (2 * l.XS)
stack = self.RowStack_Class(x, y, self, max_move=1, base_rank=row_rank)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
stack.SHRINK_FACTOR = 1
s.rows.append(stack)
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[row_rank][0]))
if self.HAS_WASTE:
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, 's')
l.createRoundText(s.talon, 'sss')
x += l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 's')
else:
x, y = self.width - l.XS, self.height - l.YS
s.talon = self.Talon_Class(x, y, self)
# create an invisible stacks
s.internals.append(InvisibleStack(self))
s.internals.append(InvisibleStack(self))
# default
l.defaultStackGroups()
def createGame(self, numstacks=8):
PictureGallery.createGame(self, numstacks=numstacks)
self.s.internals.append(InvisibleStack(self))
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
# set window
w = max(2 * l.XS, x, ((self.NUM_RESERVE + 1) * l.XS) + (4 * l.XM))
self.setSize(l.XM + w + 4 * l.XS + 50, l.YM + 4 * l.YS + 30)
# create stacks
for i in range(4):
for j in range(4):
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()
for i in range(self.NUM_RESERVE):
x, y = ((i + 1) * l.XS) + (2 * l.XM), l.YM
s.reserves.append(self.RESERVE_STACK(x, y, self))
# create texts 2)
if self.preview <= 1:
for i in (3, 7, 11, 15):
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(12, 16):
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,
4 * l.YS,
anchor="sw",
font=self.app.getFont("canvas_large"))
# define hands for scoring
r = s.rows
self.cribbage_hands = [
r[0:4], r[4:8], r[8:12], r[12:16],
(r[0], r[0 + 4], r[0 + 8], r[0 + 12]),
(r[1], r[1 + 4], r[1 + 8], r[1 + 12]),
(r[2], r[2 + 4], r[2 + 8], r[2 + 12]),
(r[3], r[3 + 4], r[3 + 8], r[3 + 12])
]
self.cribbage_hands = list(map(tuple, self.cribbage_hands))
# define stack-groups
l.defaultStackGroups()
return l
