def updateText(self): if self.game.preview > 1: return WasteTalonStack.updateText(self, update_rounds=0) if not self.max_rounds - 1: return t = _("Round %d") % self.round self.texts.rounds.config(text=t)
def updateText(self): if self.game.preview > 1: return WasteTalonStack.updateText(self, update_rounds=0) # t = "Round %d" % self.round t = _("Round %d/%d") % (self.round, self.max_rounds) self.texts.rounds.config(text=t) t = _("Deal %d") % self.DEAL[self.round-1] self.texts.misc.config(text=t)
def canDealCards(self): if not WasteTalonStack.canDealCards(self): return False for r in self.game.s.reserves: if not r.cards: return False return True
def dealCards(self, sound=False): if self.round == self.max_rounds: return 0 if self.cards: return WasteTalonStack.dealCards(self, sound) # last round num_cards = WasteTalonStack.dealCards(self, sound) wastes = [self.waste]+list(self.game.s.reserves) old_state = self.game.enterState(self.game.S_DEAL) if self.cards: if sound and not self.game.demo: self.game.startDealSample() num_cards = min(len(self.cards), 8) for i in range(num_cards): if not self.cards[-1].face_up: self.game.flipMove(self) self.game.moveMove(1, self, wastes[i], frames=4, shadow=0) if sound and not self.game.demo: self.game.stopSamples() self.game.leaveState(old_state) return num_cards
def createGame(self, rows=12): l, s = Layout(self), self.s self.setSize(l.XM + rows * l.XS, l.YM + 2 * l.YS + l.TEXT_HEIGHT + 20 * l.YOFFSET) x, y = l.XM + (rows - 4) // 2 * l.XS, l.YM for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, mod=13, max_cards=26)) x += l.XS x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT for i in range(rows): s.rows.append(RK_RowStack(x, y, self, mod=13)) x += l.XS x, y = l.XM, l.YM s.talon = WasteTalonStack(x, y, self, num_deal=2, max_rounds=1) l.createText(s.talon, 's') x = x + l.XS s.waste = WasteStack(x, y, self, max_cards=2) s.waste.CARD_XOFFSET = l.XOFFSET l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s w1 = l.XS + 12 * l.XOFFSET w, h = l.XM + 2 * l.XS + 2 * w1, l.YM + 4 * l.YS self.setSize(w, h) for x, y in ( (l.XM, l.YM), (l.XM + w1 + 2 * l.XS + l.XM, l.YM), (l.XM, l.YM + 3 * l.YS), (l.XM + w1 + 2 * l.XS + l.XM, l.YM + 3 * l.YS), ): stack = SS_RowStack(x, y, self, max_move=1) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) i = 0 for x, y in ( (l.XM + w1, l.YM), (l.XM + w1 + l.XS, l.YM), (l.XM + w1 - 2 * l.XS - l.XS / 2 - l.XM, l.YM + 1.5 * l.YS), (l.XM + w1 - l.XS - l.XS / 2 - l.XM, l.YM + 1.5 * l.YS), (l.XM + w1 + 2 * l.XS + l.XS / 2 + l.XM, l.YM + 1.5 * l.YS), (l.XM + w1 + 3 * l.XS + l.XS / 2 + l.XM, l.YM + 1.5 * l.YS), (l.XM + w1, l.YM + 3 * l.YS), (l.XM + w1 + l.XS, l.YM + 3 * l.YS), ): s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4)) i += 1 x, y = l.XM + w1, l.YM + 1.5 * l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=4) l.createText(s.talon, 's') l.createRoundText(s.talon, 'nn') x += l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, 's') l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s h0 = l.YS + 3 * l.YOFFSET self.setSize(l.XM + 10 * l.XS, l.YM + l.YS + l.TEXT_HEIGHT + 2 * h0) 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 += l.XS for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4)) 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(2): x = l.XM for j in range(10): s.rows.append( DoubleLine_RowStack(x, y, self, max_cards=2, max_move=1, max_accept=1, base_rank=NO_RANK)) x += l.XS y += h0 l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+10*l.XS, l.YM+4*l.YS+l.TEXT_HEIGHT) # create stacks x, y, = l.XS, l.YM for i in range(4): s.foundations.append(self.Foundation_Class(x, y, self, suit=i, max_move=0)) x += l.XS x += 2*l.XM for i in range(4): s.foundations.append(self.Foundation_Class(x, y, self, suit=i, max_move=0, base_rank=KING, dir=-1)) x += l.XS y = l.YM+l.YS for i in range(2): x = l.XM for j in range(10): stack = self.RowStack_Class(x, y, self, max_move=1, max_accept=1) s.rows.append(stack) stack.CARD_XOFFSET = stack.CARD_YOFFSET = 0 x += l.XS y += l.YS x, y = l.XM + 9*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 = WasteStack(x, y, self, max_cards=1) # define stack-groups l.defaultStackGroups()
def createGame(self, max_rounds=1): l, s = Layout(self), self.s self.setSize(l.XM+11*l.XS, l.YM+5*l.YS) y = l.YM for i in range(4): x = l.XM for j in range(4): stack = self.RowStack_Class(x, y, self, max_move=1) s.rows.append(stack) stack.CARD_YOFFSET = 0 x += l.XS y += l.YS y = l.YM for i in range(4): x = l.XM+7*l.XS for j in range(4): stack = self.RowStack_Class(x, y, self, max_move=1) s.rows.append(stack) stack.CARD_YOFFSET = 0 x += l.XS y += l.YS x, y = l.XM+4.5*l.XS, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) s.foundations.append(SS_FoundationStack(x+l.XS, y, self, suit=i)) y += l.YS x, y = l.XM+4.5*l.XS, self.height-l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds) l.createText(s.talon, 'sw') x += l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, 'se') l.defaultStackGroups()
def createGame(self, max_rounds=1): l, s = Layout(self), self.s w, h = 3 * l.XM + 5 * l.XS, l.YM + 4 * l.YS if max_rounds > 1: h += l.TEXT_HEIGHT + l.TEXT_MARGIN self.setSize(w, h) x, y = l.XM, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) y += l.YS x, y = 3 * l.XM + 4 * l.XS, l.YM for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1)) y += l.YS y = l.YM for i in range(3): x = 2 * l.XM + l.XS for j in range(3): s.rows.append( BasicRowStack(x, y, self, max_cards=1, max_accept=1)) x += l.XS y += l.YS x, y = 2 * l.XM + l.XS + l.XS // 2, l.YM + 3 * l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds) x += l.XS s.waste = WasteStack(x, y, self) if max_rounds > 1: l.createText(s.talon, 's') l.createRoundText(s.talon, 'sss') l.createText(s.waste, 's') else: l.createText(s.talon, 'sw') l.createText(s.waste, 'se') l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 8 * l.XS, l.YM + 4 * l.YS) # create stacks x, y, = l.XM, l.YM for i in range(4): s.foundations.append( self.Foundation_Class(x, y, self, i, dir=2, mod=13)) x = x + l.XS for i in range(4): s.foundations.append( self.Foundation_Class(x, y, self, i, dir=2, mod=13, base_rank=1)) x = x + l.XS for i in range(2): x, y, = l.XM + ((4, 3)[i]) * l.XS, l.YM + (i + 1) * l.YS for j in range((4, 5)[i]): s.reserves.append(ReserveStack(x, y, self, max_accept=0)) x = x + l.XS x, y = l.XM, self.height - l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=2) l.createText(s.talon, "n") l.createRoundText(s.talon, 'nnn') x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "n") # define stack-groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 8 * l.XS, l.YM + 4 * l.YS) x, y = l.XM, l.YM for i in range(8): s.foundations.append( SS_FoundationStack(x, y, self, suit=i // 2, base_rank=4, dir=-1, mod=13, max_cards=6)) x += l.XS x, y = l.XM, l.YM + l.YS for i in range(8): s.foundations.append( SS_FoundationStack(x, y, self, suit=i // 2, base_rank=5, max_cards=7)) x += l.XS x, y = l.XM + 3 * l.XS, l.YM + 3 * l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=2) l.createText(s.talon, 'n') l.createRoundText(self.s.talon, 'nnn') x += l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, 'n') l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+7.5*l.XS, l.YM+3.8*l.YS) x0, y0 = l.XM, l.YM for xx, yy in ((4, 0.4), (3, 0.2), (2, 0.0), (1, 0.2), (0, 0.7), (1, 1.2), (2, 1.4), (3, 1.6), (4, 2.0), (3, 2.6), (2, 2.8), (1, 2.6), (0, 2.4), ): x, y = x0+xx*l.XS, y0+yy*l.YS s.foundations.append(RK_FoundationStack(x, y, self, suit=ANY_SUIT, max_cards=8, mod=13, max_move=0)) x, y = l.XM+5.5*l.XS, l.YM+2*l.YS for i in (0, 1): stack = Calculation_RowStack(x, y, self, max_move=1, max_accept=1) stack.CARD_YOFFSET = 0 s.rows.append(stack) l.createText(stack, 's') x += l.XS x, y = l.XM+5.5*l.XS, l.YM+l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, 'nw') x += l.XS s.waste = WasteStack(x, y, self, max_cards=1) l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 8 * l.XS, l.YM + 4 * l.YS + l.TEXT_HEIGHT) x0 = l.XM + 1.5 * l.XS for k in (0, 1): suit = 0 for i, j in ((1, 0), (0, 0.5), (2, 0.5), (1, 1)): x, y = x0 + i * l.XS, l.YM + j * l.YS s.foundations.append(AC_FoundationStack(x, y, self, suit=suit)) suit += 1 x0 += 3.5 * l.XS x, y = l.XM, l.YM + l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS) l.createText(s.talon, 'se') y += l.YS s.waste = WasteStack(x, y, self) l.createText(s.waste, 'se') x, y = l.XM + 3.75 * l.XS, l.YM + 2 * l.YS for i in (0, 1): stack = KingAC_RowStack(x, y, self, max_move=1) stack.getBottomImage = stack._getReserveBottomImage s.rows.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0 x += l.XS x, y = l.XM + 2.75 * l.XS, l.YM + 3 * l.YS for i in range(4): stack = BasicRowStack(x, y, self) s.reserves.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0 l.createText(stack, 's') x += l.XS l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 10 * l.XS, l.YM + 4 * l.YS) # create stacks for i in range(4): x, y, = l.XM + i * l.XS, l.YM s.rows.append(BasicRowStack(x, y, self, max_accept=0)) for i in range(4): x, y, = l.XM + 4 * l.XS, l.YM + i * l.YS s.foundations.append( self.Foundation_Class(x, y, self, i, dir=2, mod=13)) x += l.XS s.foundations.append( self.Foundation_Class(x, y, self, i, dir=2, mod=13, base_rank=1)) for i in range(4): for j in range(4): x, y, = l.XM + (j + 6) * l.XS, l.YM + i * l.YS s.reserves.append(ReserveStack(x, y, self, max_accept=0)) x, y = l.XM + l.XS, self.height - l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, "sw") x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "se") # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 9 * l.XS, l.YM + 5 * l.YS) # create stacks x, y = l.XM + l.XS, l.YM for i in range(8): s.foundations.append( BritishConstitution_Foundation(x, y, self, suit=int(i / 2), max_cards=11)) x += l.XS y = l.YM + l.YS for i in range(4): x = l.XM + l.XS for j in range(8): stack = self.RowStack_Class(x, y, self, max_move=1) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0 s.rows.append(stack) x += l.XS y += l.YS x, y = l.XM, l.YM s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, "s") y += l.YS + l.TEXT_HEIGHT s.waste = WasteStack(x, y, self) l.createText(s.waste, "s") # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 5.5 * l.XS, l.YM + 4 * l.YS) # create stacks for dx, dy in ((0, 0), (1, 0), (2, 0), (0, 1), (2, 1), (0, 2), (2, 2)): x, y = l.XM + (2 * dx + 5) * l.XS // 2, l.YM + (2 * dy + 1) * l.YS // 2 s.rows.append(ReserveStack(x, y, self)) dx, dy = 1, 2 x, y = l.XM + (2 * dx + 5) * l.XS // 2, l.YM + (2 * dy + 1) * l.YS // 2 s.foundations.append( Doublets_Foundation(x, y, self, ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=48)) l.createText(s.foundations[0], "s") # help = "A, 2, 4, 8, 3, 6, Q, J, 9, 5, 10, 7, A, ..." # self.texts.help = MfxCanvasText( # self.canvas, x + l.CW//2, y + l.YS + l.YM, anchor="n", text=help) x, y = l.XM, l.YM + 3 * l.YS // 2 s.talon = WasteTalonStack(x, y, self, max_rounds=3) l.createText(s.talon, "s") x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "s") l.createRoundText(s.talon, 'nn') # define stack-groups l.defaultStackGroups()
def createGame(self, rows=16): # create layout l, s = Layout(self, card_y_space=20), self.s # set window self.setSize(l.XM + (5 + rows // 4) * l.XS, l.YM + 4 * l.YS) # create stacks x, y, = l.XM, l.YM s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, "s") x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "s") for i in range(4): x = 3 * l.XS for j in range(rows // 4): stack = self.RowStack_Class(x, y, self) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 1 s.rows.append(stack) x = x + l.XS y = y + l.YS x, y = self.width - l.XS, l.YM for i in range(4): stack = self.Foundation_Class(x, y, self, suit=i, max_move=0, dir=0) l.createText(stack, "sw") s.foundations.append(stack) y = y + l.YS # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 8.5 * l.XS, l.YM + 3 * l.YS + 14 * l.XOFFSET) # create stacks x, y, = l.XM, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) x += l.XS x += l.XS / 2 for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1)) x += l.XS x, y = l.XM, l.YM + l.YS for j in range(4): s.rows.append(AC_RowStack(x, y, self)) x += l.XS x += l.XS / 2 for j in range(4): s.rows.append(AC_RowStack(x, y, self, dir=1)) x += l.XS x, y = self.width - 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 = WasteStack(x, y, self) l.createText(s.waste, 'n') # define stack-groups l.defaultStackGroups()
def createGame(self): lay, s = Layout(self), self.s self.setSize(lay.XM + 8 * lay.XS, lay.YM + 2 * lay.YS + 12 * lay.YOFFSET) x, y = lay.XM, lay.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) s.foundations.append( SS_FoundationStack(x + 4 * lay.XS, y, self, suit=i, base_rank=KING, dir=-1)) x += lay.XS x, y = lay.XM, lay.YM + lay.YS s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3) lay.createText(s.talon, 'ne') y += lay.YS s.waste = WasteStack(x, y, self) lay.createText(s.waste, 'ne') x, y = lay.XM + 2 * lay.XS, lay.YM + lay.YS for i in range(4): s.rows.append(AC_RowStack(x, y, self, base_rank=6)) x += lay.XS x += lay.XS stack = OpenStack(x, y, self) s.reserves.append(stack) stack.CARD_YOFFSET = lay.YOFFSET lay.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s w = l.XM + max(7 * l.XS, 2 * l.XS + 23 * l.XOFFSET) h = l.YM + 5.5 * l.YS self.setSize(w, h) x, y = l.XM + (w - 7 * l.XS) // 2, l.YM s.rows = self._createPyramid(l, x, y, 7) x, y = l.XM, self.height - l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3) l.createText(s.talon, "n") x += l.XS s.waste = Pyramid_Waste(x, y, self, max_accept=1) s.waste.CARD_XOFFSET = l.XOFFSET l.createText(s.waste, "n") x, y = self.width - l.XS, l.YM s.foundations.append( self.Foundation_Class(x, y, self, suit=ANY_SUIT, dir=0, base_rank=ANY_RANK, max_move=0, max_cards=52)) l.createText(s.foundations[0], 'nw') l.defaultStackGroups() self.sg.openstacks.append(s.waste)
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 10 * l.XS, l.YM + 3 * l.YS + 14 * l.YOFFSET) # create stacks x, y = l.XM, l.YM for i in range(7): s.reserves.append(LockedCards_Reserve(x, y, self)) x += l.XS x, y = l.XM, l.YM + l.YS for i in range(8): s.foundations.append( self.Foundation_Class(x, y, self, suit=ANY_SUIT, max_move=0)) x += l.XS x, y = l.XM, l.YM + 2 * l.YS for i in range(8): s.rows.append(self.RowStack_Class(x, y, self)) x += l.XS x, y = self.width - l.XS, self.height - l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=3) l.createText(s.talon, 'n') l.createRoundText(s.talon, 'nnn') x -= l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, 'n') # define stack-groups l.defaultStackGroups()
def createGame(self, max_rounds=-1, num_deal=1, **layout): # create layout l, s = Layout(self), self.s kwdefault(layout, rows=9, waste=1, texts=1, playcards=19) self.Layout_Method(l, **layout) self.setSize(l.size[0], l.size[1]) # create stacks s.talon = WasteTalonStack(l.s.talon.x, l.s.talon.y, self, max_rounds=max_rounds, num_deal=num_deal) s.waste = WasteStack(l.s.waste.x, l.s.waste.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 l.defaultAll() # extra if max_rounds > 1: anchor = 'nn' if layout.get("texts"): anchor = 'nnn' l.createRoundText(s.talon, anchor) return l
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(7 * l.XS + l.XM, 5 * l.YS + l.YM) # create stacks for i in range(7): x = l.XM + (6 - i) * l.XS // 2 y = l.YM + l.YS + i * l.YS // 2 for j in range(i + 1): s.rows.append(Pyramid_RowStack(x, y, self)) x = x + l.XS x, y = l.XM, l.YM s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, "s") x = x + l.XS s.waste = Pyramid_Waste(x, y, self, max_accept=1) l.createText(s.waste, "s") s.waste.CARD_XOFFSET = 14 x, y = self.width - l.XS, l.YM s.foundations.append( Pyramid_Foundation(x, y, self, suit=ANY_SUIT, dir=0, base_rank=ANY_RANK, max_move=0, max_cards=52)) # define stack-groups self.sg.talonstacks = [s.talon] + [s.waste] self.sg.openstacks = s.rows + self.sg.talonstacks self.sg.dropstacks = s.rows + self.sg.talonstacks
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 dealCards(self, sound=False): self.num_deal = 4-self.round return WasteTalonStack.dealCards(self, sound=sound)
def canDealCards(self): if not WasteTalonStack.canDealCards(self): return False return not self.game.isGameWon()
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 canDealCards(self): if self.game.getState() == 0: return False return WasteTalonStack.canDealCards(self)
def createGame(self, max_rounds=1, num_deal=1): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + (8.5 * l.XS), l.YM + ((2 + len(self.FOUNDATION_SETS)) * l.YS)) # create stacks x, y = 2 * l.XM, l.YM w1, w2 = (10 * (l.XS + l.XM)) / self.NUM_RESERVES, 2 * l.XS if w2 + 13 * l.XOFFSET > w1: l.XOFFSET = int((w1 - w2) / 13) for i in range(self.NUM_RESERVES): stack = OpenStack(x, y, self) stack.CARD_XOFFSET = l.XOFFSET l.createText(stack, "sw") s.reserves.append(stack) x += (9 / self.NUM_RESERVES) * l.XS x, y = l.XM, y + l.YS font = self.app.getFont("canvas_default") for i in self.FOUNDATION_SETS: for j in range(4): stack = AcesAndKings_FoundationStack(x, y, self, suit=j, base_rank=i[0], dir=1, max_cards=(13 - i[0])) if self.preview <= 1: stack.texts.misc = MfxCanvasText(self.canvas, x + l.CW // 2, y + l.CH // 2, anchor="center", font=font) stack.texts.misc.config(text=(RANKS[i[0]][0])) s.foundations.append(stack) x = x + l.XS x = x + (l.XS / 2) for j in range(4): stack = AcesAndKings_FoundationStack(x, y, self, suit=j, base_rank=i[1], dir=-1, max_cards=(i[1] + 1)) if self.preview <= 1: stack.texts.misc = MfxCanvasText(self.canvas, x + l.CW // 2, y + l.CH // 2, anchor="center", font=font) stack.texts.misc.config(text=(RANKS[i[1]][0])) s.foundations.append(stack) x = x + l.XS x, y = l.XM, y + l.YS x += (2.5 * l.XM) s.talon = WasteTalonStack( x, y, self, max_rounds=max_rounds, num_deal=num_deal) l.createText(s.talon, "sw") x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "se", text_format="%D") x = ((8.5 - self.NUM_TABLEAU) * l.XS) + l.XM for i in range(self.NUM_TABLEAU): s.rows.append(AcesAndKings_RowStack(x, y, self, max_accept=1)) x = x + l.XS # define stack-groups l.defaultStackGroups()
def 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 canDealCards(self): if self.game.base_rank is None: return False return WasteTalonStack.canDealCards(self)
def dealCards(self, sound=False): self.num_deal = 4 - self.round WasteTalonStack.dealCards(self, sound=sound)
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): 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, 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()