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