def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
playcards = 5
w1, w2 = 8*l.XS+l.XM, 2*l.XS
if w2 + 52*l.XOFFSET > w1:
l.XOFFSET = int((w1 - w2) / 52)
self.setSize(w1, l.YM+3*l.YS+(playcards-1)*l.YOFFSET+l.TEXT_HEIGHT)
# create stacks
x, y = l.XM + l.XS // 2, l.YM
for i in range(7):
s.rows.append(Golf_RowStack(x, y, self))
x = x + l.XS
x, y = l.XM, self.height - l.YS
s.talon = Golf_Talon(x, y, self, max_rounds=1)
l.createText(s.talon, "n")
x = x + l.XS
s.waste = self.Waste_Class(x, y, self)
s.waste.CARD_XOFFSET = l.XOFFSET
l.createText(s.waste, "n")
# the Waste is also our only Foundation in this game
s.foundations.append(s.waste)
# define stack-groups (non default)
self.sg.openstacks = [s.waste]
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows
def createGame(self, columns=7):
# create layout
layout, s = Layout(self), self.s
# set window
playcards = 5
w1, w2 = (columns + 1) * layout.XS + layout.XM, 2 * layout.XS
totalcards = 52 * self.gameinfo.decks
if w2 + totalcards * layout.XOFFSET > w1:
layout.XOFFSET = int((w1 - w2) / totalcards)
self.setSize(w1, layout.YM + 3 * layout.YS +
(playcards - 1) * layout.YOFFSET + layout.TEXT_HEIGHT)
# create stacks
x, y = layout.XM + layout.XS // 2, layout.YM
for i in range(columns):
s.rows.append(Golf_RowStack(x, y, self))
x = x + layout.XS
x, y = layout.XM, self.height - layout.YS
s.talon = Golf_Talon(x, y, self, max_rounds=1)
layout.createText(s.talon, "n")
x = x + layout.XS
s.waste = self.Waste_Class(x, y, self)
s.waste.CARD_XOFFSET = layout.XOFFSET
layout.createText(s.waste, "n")
# the Waste is also our only Foundation in this game
s.foundations.append(s.waste)
# define stack-groups (non default)
self.sg.openstacks = [s.waste]
self.sg.talonstacks = [s.talon]
self.sg.dropstacks = s.rows
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# compute best XOFFSET
xoffset = int(l.XS * 8 / self.gameinfo.ncards)
if xoffset < l.XOFFSET:
l.XOFFSET = xoffset
# Set window size
w, h = l.XM + l.XS * 10, l.YM + l.YS * 4
self.setSize(w, h)
# Extra settings
self.game_score = 52
self.hand_score = self.sequence = 0
self.peaks = [0] * 3
# Create rows
x, y = l.XM + l.XS * 1.5, l.YM
for i in range(3):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS * 3
x, y = l.XM + l.XS, y + l.YS * .5
for i in range(3):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS * 2
x, y = l.XM + l.XS * .5, y + l.YS * .5
for i in range(9):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
x, y = l.XM, y + l.YS * .5
for i in range(10):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
# Create talon
x, y = l.XM, y + l.YM + l.YS
s.talon = ThreePeaks_TalonStack(x, y, self, num_deal=1, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = self.Waste_Class(x, y, self)
s.waste.CARD_XOFFSET = l.XOFFSET
s.foundations.append(s.waste)
l.createText(s.waste, "s")
# Create text for scores
if self.preview <= 1:
self.texts.info = MfxCanvasText(
self.canvas,
l.XM + l.XS * 3,
h - l.YM,
anchor="sw",
font=self.app.getFont("canvas_default"))
# Define stack groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
# set window
# compute best XOFFSET
xoffset = int(l.XS * 8 / self.gameinfo.ncards)
if xoffset < l.XOFFSET:
l.XOFFSET = xoffset
# Set window size
w, h = l.XM + l.XS * 10, l.YM + l.YS * 4
self.setSize(w, h)
# Extra settings
self.game_score = 0
self.hand_score = self.sequence = 0
self.score_counted = False
self.peaks = [0] * 3
# Create rows
x, y = l.XM + l.XS * 1.5, l.YM
for i in range(3):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS * 3
x, y = l.XM + l.XS, y + l.YS * .5
for i in range(3):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS * 2
x, y = l.XM + l.XS * .5, y + l.YS * .5
for i in range(9):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
x, y = l.XM, y + l.YS * .5
for i in range(10):
s.rows.append(ThreePeaks_RowStack(x, y, self))
x = x + l.XS
# Create talon
x, y = l.XM, y + l.YM + l.YS
s.talon = ThreePeaks_TalonStack(x, y, self, num_deal=1, max_rounds=1)
l.createText(s.talon, "s")
x = x + l.XS
s.waste = self.Waste_Class(x, y, self)
s.waste.CARD_XOFFSET = l.XOFFSET
s.foundations.append(s.waste)
l.createText(s.waste, "s")
# Create text for scores
if self.preview <= 1:
self.texts.info = MfxCanvasText(
self.canvas,
l.XM + l.XS * 3, h - l.YM,
anchor="sw",
font=self.app.getFont("canvas_default"))
# Define stack groups
l.defaultStackGroups()
def createGame(self, max_rounds=1, num_deal=1, rows=10,
playcards=12, XCARDS=64, XOFFSET=None):
# create layout
if XOFFSET is None:
l, s = Layout(self), self.s
else:
l, s = Layout(self, XOFFSET=XOFFSET), self.s
# set window
# (compute best XOFFSET - up to 64/72 cards can be in the Waste)
decks = self.gameinfo.decks
maxrows = max(rows, 4*decks)
if maxrows <= 12:
maxrows += 1
w1, w2 = maxrows*l.XS+l.XM, 2*l.XS
if w2 + XCARDS * l.XOFFSET > w1:
l.XOFFSET = int((w1 - w2) / XCARDS)
# (piles up to 12 cards are playable without overlap
# in default window size)
h = max(2*l.YS, l.YS+(playcards-1)*l.YOFFSET)
self.setSize(w1, l.YM + l.YS + h + l.YS + l.TEXT_HEIGHT)
# create stacks
# foundations
x = l.XM + (maxrows - 4*decks) * l.XS // 2
y = l.YM
for i in range(4*decks):
s.foundations.append(
self.Foundation_Class(
x, y, self,
suit=i//decks, max_move=self.FOUNDATION_MAX_MOVE))
x = x + l.XS
# rows
x = l.XM + (maxrows - rows) * l.XS // 2
y = l.YM + l.YS
for i in range(rows):
s.rows.append(self.RowStack_Class(x, y, self,
max_move=self.ROW_MAX_MOVE))
x = x + l.XS
# talon, waste
x = self.width - l.XS
y = self.height - l.YS
s.talon = WasteTalonStack(x, y, self,
max_rounds=max_rounds, num_deal=num_deal)
l.createText(s.talon, "n")
if max_rounds > 1:
l.createRoundText(s.talon, 'nnn')
x -= l.XS
s.waste = WasteStack(x, y, self)
s.waste.CARD_XOFFSET = -l.XOFFSET
l.createText(s.waste, "n")
# define stack-groups
l.defaultStackGroups()
def createGame(self):
# create layout
l, s = Layout(self), self.s
ROWS = 7
# set size so that at least 2//3 of a card is visible with 20 cards
h = l.CH * 2 // 27 * l.YOFFSET
h = l.YM + max(h, 5 * l.YS)
# create rows
x, y = l.XM, l.YM
w1, w2 = (7 * (l.XS + l.XM)), (2 * l.XS)
if w2 + 13 * l.XOFFSET > w1:
l.XOFFSET = int((w1 - w2) / 13)
reserve = OpenStack(x * 3, y, self)
reserve.CARD_XOFFSET = l.XOFFSET
l.createText(reserve, "sw")
s.reserves.append(reserve)
y += l.YS
for i in range(ROWS):
self.s.rows.append(self.RowStack_Class(x, y, self))
x += l.XS
# Don't know why this is necessary for the Yukon layout.
# But we should probably figure out how to get this to work
# like other games.
self.setRegion(self.s.rows, (-999, -999, x - l.CW // 2, 999999))
# create foundations
y = l.YM
for suit in range(4):
self.s.foundations.append(self.Foundation_Class(
x, y, self, suit=suit, max_move=0))
y += l.YS
x, y = l.XM, h - l.YS
self.s.talon = self.Talon_Class(x, y, self)
# set window
self.setSize(l.XM + 8 * l.XS, h)
l.defaultAll()
def createGame(self, rows=3, columns=6):
layout, s = Layout(self), self.s
decks = self.gameinfo.decks
maxrows = max(columns, 2 + decks * 4)
self.setSize(layout.XM + maxrows * layout.XS,
layout.YM + (rows + 1) * layout.YS)
x, y = layout.XM, layout.YM
s.talon = TalonStack(x, y, self)
layout.createText(s.talon, 'ne')
x, y = layout.XM + 2 * layout.XS, layout.YM
for found in self.Foundation_Classes:
if self.SEPARATE_FOUNDATIONS:
for i in range(4):
s.foundations.append(found(x, y, self, suit=i))
x += layout.XS
else:
s.foundations.append(found(x, y, self, suit=ANY_SUIT))
if self.SPREAD_FOUNDATION:
w1, w2 = 6 * layout.XS + layout.XM, 2 * layout.XS
totalcards = self.gameinfo.ncards
if w2 + totalcards * layout.XOFFSET > w1:
layout.XOFFSET = int((w1 - w2) / totalcards)
s.foundations[0].CARD_XOFFSET = layout.XOFFSET
y = layout.YM + layout.YS
for i in range(rows):
x = layout.XM + (maxrows - columns) * layout.XS // 2
for j in range(columns):
s.rows.append(Vague_RowStack(x, y, self))
x += layout.XS
y += layout.YS
layout.defaultStackGroups()
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()
