def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = max(2*l.XM+2*l.XS+(5+13)*l.XOFFSET, l.XM + 8*l.XS), l.YM+8*l.YS self.setSize(w, h) # create stacks x, y, = l.XM, l.YM for i in range(4): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) y += l.YS x, y, = 2*l.XM+l.XS+5*l.XOFFSET, l.YM for i in range(4): stack = Osmosis_Foundation( x, y, self, i, base_rank=ANY_RANK, max_move=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.foundations.append(stack) y += l.YS y = l.YM + 4*l.YS for i in range(4): x = l.XM for j in range(8): s.reserves.append(OpenStack(x, y, self, max_accept=0)) x += l.XS y += l.YS x, y = w-l.XS, l.YM s.talon = InitialDealTalonStack(x, y, self) # define stack-groups l.defaultStackGroups()
def createGame(self, rows=13, reserves=False): # create layout l, s = Layout(self), self.s # set window w, h = l.XM+rows*l.XS, l.YM+2*l.YS+20*l.YOFFSET self.setSize(w, h) # create stacks x, y, = l.XM+(rows-4)*l.XS//2, l.YM for i in range(4): stack = Osmosis_Foundation( x, y, self, i, base_rank=ANY_RANK, max_move=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET s.foundations.append(stack) x += l.XS x, y, = l.XM, h-2*l.YS-3*l.YOFFSET for i in range(rows): s.rows.append(BasicRowStack(x, y, self)) x += l.XS x, y, = l.XM, h-l.YS-3*l.YOFFSET for i in range(rows): s.rows.append(BasicRowStack(x, y, self)) x += l.XS if reserves: s.reserves.append(ReserveStack(l.XM, l.YM, self)) s.reserves.append(ReserveStack(w-l.XS, l.YM, self)) s.talon = InitialDealTalonStack(l.XM, l.YM, self) # define stack-groups l.defaultStackGroups()
def createGame(self, max_rounds=-1, num_deal=1): # create layout l, s = Layout(self), self.s # set window w, h = 3*l.XM+3*l.XS+(4+13)*l.XOFFSET, l.YM+4*l.YS self.setSize(w, h) # create stacks x, y, = l.XM, l.YM for i in range(4): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) y = y + l.YS x, y, = 2*l.XM+l.XS+4*l.XOFFSET, l.YM for i in range(4): stack = self.Foundation_Class(x, y, self, suit=i, base_rank=ANY_RANK, max_move=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.foundations.append(stack) y = y + l.YS x, y, = self.width - l.XS, l.YM + l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=max_rounds, num_deal=num_deal) l.createText(s.talon, "sw") y = y + l.YS s.waste = WasteStack(x, y, self) l.createText(s.waste, "sw") # define stack-groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s w0 = l.XS+5*l.XOFFSET self.setSize(l.XM+5*w0, l.YM+5*l.YS) x, y = l.XM, l.YM for i in range(3): s.reserves.append(TripleAlliance_Reserve(x, y, self)) x += l.XS x, y = self.width-l.XS, l.YM s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_move=0, max_accept=0, max_cards=52)) l.createText(s.foundations[0], 'nw') y = l.YM+l.YS nstacks = 0 for i in range(4): x = l.XM for j in range(5): stack = BasicRowStack(x, y, self, max_accept=0) s.rows.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 x += w0 nstacks += 1 if nstacks >= 18: break y += l.YS x, y = self.width-l.XS, 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+8.5*l.XS, l.YM+4*l.YS) y = l.YM suit = 0 for i in (0, 1, 3, 4): x = l.XM+(2+i)*l.XS s.foundations.append(SS_FoundationStack(x, y, self, suit=suit)) suit += 1 x, y = 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 for i, j in ((0, 0), (1, 0), (2, 0), (5, 0), (6, 0), (7, 0), (0, 1), (1, 1), (2, 1), (5, 1), (6, 1), (7, 1), ): x, y = l.XM+(0.5+i)*l.XS, l.YM+(1.5+j)*l.YS stack = BasicRowStack(x, y, self, max_accept=0) s.rows.append(stack) stack.CARD_YOFFSET = 0 x, y = l.XM, l.YM s.talon = DealRowRedealTalonStack(x, y, self, max_rounds=3) l.createText(s.talon, 'se') l.createRoundText(s.talon, 'ne') l.defaultStackGroups()
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): assert ncards == 1 and to_stack in self.game.s.rows if to_stack.cards: self._dropPairMove(ncards, to_stack, frames=-1, shadow=shadow) else: BasicRowStack.moveMove( self, ncards, to_stack, frames=frames, shadow=shadow)
def createGame(self): layout, s = Layout(self), self.s w0 = layout.XS+5*layout.XOFFSET self.setSize(layout.XM+5*w0, layout.YM+5*layout.YS) x, y = layout.XM, layout.YM for i in range(3): s.reserves.append(TripleAlliance_Reserve(x, y, self)) x += layout.XS x, y = self.width-layout.XS, layout.YM s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_move=0, max_accept=0, max_cards=52)) layout.createText(s.foundations[0], 'nw') y = layout.YM+layout.YS nstacks = 0 for i in range(4): x = layout.XM for j in range(5): stack = BasicRowStack(x, y, self, max_accept=0) s.rows.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = layout.XOFFSET, 0 x += w0 nstacks += 1 if nstacks >= 18: break y += layout.YS x, y = self.width-layout.XS, self.height-layout.YS s.talon = InitialDealTalonStack(x, y, self) layout.defaultStackGroups()
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): assert ncards == 1 if self.cards[-1].rank == KING: assert to_stack in self.game.s.foundations BasicRowStack.moveMove( self, ncards, to_stack, frames=frames, shadow=shadow) else: MonteCarlo_RowStack.moveMove( self, ncards, to_stack, frames=frames, shadow=shadow)
def createGame(self, max_rounds=2): l, s = Layout(self), self.s self.setSize(l.XM + 10 * l.XS, l.YM + 5 * l.YS) lay = ( (1.5, 0), (2.5, 0.3), (3, 1.3), (2.5, 2.3), (1.5, 2.6), (0.5, 2.3), (0, 1.3), (0.5, 0.3), ) suit = 0 x0, y0 = l.XM + l.XS, l.YM for xx, yy in lay: x, y = x0 + xx * l.XS, y0 + yy * l.YS s.foundations.append( SS_FoundationStack(x, y, self, suit=suit // 2, base_rank=6, max_cards=7)) suit += 1 suit = 0 x0, y0 = l.XM + 5 * l.XS, l.YM for xx, yy in lay: x, y = x0 + xx * l.XS, y0 + yy * l.YS s.foundations.append( SS_FoundationStack(x, y, self, suit=suit // 2, base_rank=5, dir=-1, max_cards=6)) suit += 1 x, y = l.XM, l.YM + 4 * l.YS for i in range(8): stack = BasicRowStack(x, y, self) stack.CARD_YOFFSET = 0 s.rows.append(stack) x += l.XS x += l.XS s.talon = DealRowRedealTalonStack(x, y, self, max_rounds=2) l.createText(s.talon, 'nw') l.createRoundText(s.talon, 'sw') l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 11 * l.XS, 2 * l.YM + max(2 * l.YS + 12 * l.YOFFSET, 5 * l.YS)) x, y, = l.XM + 1.5 * l.XS, l.YM for i in range(8): s.foundations.append(SS_FoundationStack(x, y, self, suit=i % 4)) x += l.XS x, y = l.XM + 1.5 * l.XS, 2 * l.YM + l.YS for i in range(8): s.reserves.append( BasicRowStack(x, y, self, max_move=1, max_accept=0)) x += l.XS x, y = l.XM, 2 * l.YM + l.YS for i in range(4): stack = Saxony_Reserve(x, y, self, max_move=1) self.s.rows.append(stack) stack.CARD_YOFFSET = 0 y += l.YS x, y = self.width - l.XS, 2 * l.YM + l.YS for i in range(4): self.s.reserves.append(ReserveStack(x, y, self)) y += l.YS s.talon = Saxony_Talon(l.XM, l.YM, self) l.createText(s.talon, "ne") l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False # check if self.cards or self.game.s.talon.cards: return False return True
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if from_stack is self.game.s.talon or \ from_stack in self.game.s.reserves: return True return False
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if self.id % self.game.RSTEP == 0: return cards[0].rank == self.game.RBASE left = self.game.s.rows[self.id - 1] return left.cards and left.cards[-1].rank + 1 == cards[0].rank
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 10 * l.XS, l.YM + 5 * l.YS) x, y = l.XM, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) s.foundations.append( SS_FoundationStack(x + 6 * l.XS, y, self, suit=i)) x += l.XS x, y = l.XM + 4 * l.XS, l.YM r = list(range(11)) for i in range(5, 0, -1): for j in r[i:-i]: x, y = l.XM + (j - 0.5) * l.XS, l.YM + (5 - i) * l.YS s.rows.append(BasicRowStack(x, y, self, max_accept=0)) x, y = l.XM, l.YM + 1.5 * l.YS 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, playcards=20, rows=8, reserves=1): decks = self.gameinfo.decks l, s = Layout(self), self.s self.setSize( l.XM + (reserves + 0.5 + rows) * l.XS, l.YM + max(2 * l.YS + 7 * l.YOFFSET, l.YS + playcards * l.YOFFSET)) x, y = self.width - l.XS, self.height - l.YS s.talon = InitialDealTalonStack(x, y, self) x, y = l.XM, l.YM for i in range(reserves): stack = ReserveStack(x, y, self, max_cards=UNLIMITED_CARDS) stack.CARD_YOFFSET = l.YOFFSET s.reserves.append(stack) x += l.XS x, y = l.XM + (reserves + 0.5 + (rows - decks * 4) / 2.0) * l.XS, l.YM for i in range(4): s.foundations.append(RK_FoundationStack(x, y, self, suit=ANY_SUIT)) x += l.XS x, y = l.XM + (reserves + 0.5) * l.XS, l.YM + l.YS for i in range(rows): s.rows.append(BasicRowStack(x, y, self, base_rank=NO_RANK)) x += l.XS l.defaultStackGroups()
def createGame(self, rows=8, reserves=4, playcards=6): l, s = Layout(self), self.s self.setSize(l.XM + rows * l.XS, l.YM + 3 * l.YS + playcards * l.YOFFSET) dx = (self.width - l.XM - (reserves + 1) * l.XS) // 3 x, y = l.XM + dx, l.YM for i in range(reserves): s.reserves.append(ReserveStack(x, y, self)) x += l.XS x += dx max_cards = 52 * self.gameinfo.decks s.foundations.append( RK_FoundationStack(x, y, self, base_rank=ANY_RANK, mod=13, max_cards=max_cards)) l.createText(s.foundations[0], 'ne') x, y = l.XM, l.YM + l.YS for i in range(rows): s.rows.append(BasicRowStack(x, y, self)) x += l.XS s.talon = InitialDealTalonStack(l.XM, self.height - l.YS, self) l.defaultAll()
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True c1, c2 = self.cards[-1], cards[0] if c1.rank == c2.rank + 1: return True return c1.rank == c2.rank
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True c1, c2 = self.cards[-1], cards[0] if c1.rank == c2.rank+1: return True return c1.rank == c2.rank
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if self.game.s.talon.cards: return False if not self.cards: return True c1, c2 = self.cards[-1], cards[0] return c1.suit == c2.suit and c1.rank == c2.rank+1
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if self.game.s.talon.cards: return False if not self.cards: return True c1, c2 = self.cards[-1], cards[0] return c1.suit == c2.suit and c1.rank == c2.rank + 1
def createGame(self, max_rounds=2): l, s = Layout(self), self.s self.setSize(l.XM+10*l.XS, l.YM+5*l.YS) lay = ( (1.5, 0), (2.5, 0.3), (3, 1.3), (2.5, 2.3), (1.5, 2.6), (0.5, 2.3), (0, 1.3), (0.5, 0.3), ) suit = 0 x0, y0 = l.XM+l.XS, l.YM for xx, yy in lay: x, y = x0+xx*l.XS, y0+yy*l.YS s.foundations.append(SS_FoundationStack(x, y, self, suit=suit//2, base_rank=6, max_cards=7)) suit += 1 suit = 0 x0, y0 = l.XM+5*l.XS, l.YM for xx, yy in lay: x, y = x0+xx*l.XS, y0+yy*l.YS s.foundations.append(SS_FoundationStack(x, y, self, suit=suit//2, base_rank=5, dir=-1, max_cards=6)) suit += 1 x, y = l.XM, l.YM+4*l.YS for i in range(8): stack = BasicRowStack(x, y, self) stack.CARD_YOFFSET = 0 s.rows.append(stack) x += l.XS x += l.XS s.talon = DealRowRedealTalonStack(x, y, self, max_rounds=2) l.createText(s.talon, 'nw') l.createRoundText(s.talon, 'sw') l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if self.cards: # check the rank - an ACE equals a Six rank = self.cards[-1].rank if rank == ACE: rank = 5 if (rank + self.cap.dir) % self.cap.mod != cards[0].rank: return False return True
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if from_stack is self.game.s.waste: return True if not self.cards: return cards[0].rank == KING if (from_stack in self.game.s.rows and self.cards[-1].rank-cards[0].rank == 1): return True return False
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if from_stack is self.game.s.waste: return True if not self.cards: return cards[0].rank == KING if (from_stack in self.game.s.rows and self.cards[-1].rank - cards[0].rank == 1): return True return False
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 10 * l.XS, max(l.YM + l.YS + 20 * l.YOFFSET, 2 * l.YM + 5 * l.YS)) # create stacks x, y, = l.XM + 2 * l.XS, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) x = x + l.XS for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1)) x = x + l.XS x, y = l.XM + 2 * l.XS, 2 * l.YM + l.YS for i in range(6): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) s.rows.append(stack) if not self.ROW_YOFFSET: stack.CARD_YOFFSET = 0 x = x + l.XS x, y = l.XM, 2 * l.YM + l.YS for i in range(4): self.s.reserves.append(ReserveStack(x, y, self)) y += l.YS x, y = l.XM + 9 * l.XS, 2 * l.YM + l.YS for i in range(4): self.s.reserves.append(ReserveStack(x, y, self)) y += l.YS s.talon = Tournament_Talon(l.XM, l.YM, self, max_rounds=3) l.createText(s.talon, "se") l.createRoundText(s.talon, 'ne') # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+10*l.XS, max(l.YM+l.YS+20*l.YOFFSET, 2*l.YM+5*l.YS)) # create stacks x, y, = l.XM+2*l.XS, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) x = x + l.XS for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1)) x = x + l.XS x, y = l.XM+2*l.XS, 2*l.YM+l.YS for i in range(6): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) s.rows.append(stack) if not self.ROW_YOFFSET: stack.CARD_YOFFSET = 0 x = x + l.XS x, y = l.XM, 2*l.YM+l.YS for i in range(4): self.s.reserves.append(ReserveStack(x, y, self)) y += l.YS x, y = l.XM+9*l.XS, 2*l.YM+l.YS for i in range(4): self.s.reserves.append(ReserveStack(x, y, self)) y += l.YS s.talon = Tournament_Talon(l.XM, l.YM, self, max_rounds=3) l.createText(s.talon, "se") l.createRoundText(s.talon, 'ne') # define stack-groups l.defaultStackGroups()
def createGame(self, rows=(7, 7, 7, 5)): # create layout l, s = Layout(self), self.s # set window w, h = l.XM + max(max(rows) * (l.XS + 3 * l.XOFFSET), 9 * l.XS), l.YM + (len(rows) + 2) * l.YS self.setSize(w, h) # create stacks x, y = l.XM + (w - l.XM - 8 * l.XS) // 2, 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, base_rank=KING, suit=i, dir=-1)) x += l.XS n = 0 y = l.YM + l.YS for i in rows: x = l.XM for j in range(i): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) x += l.XS + 3 * l.XOFFSET n += 1 y += l.YS x, y = l.XM + (w - l.XM - 8 * l.XS) // 2, h - l.YS for i in range(8): s.reserves.append(ReserveStack(x, y, self)) x += l.XS s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self) # default l.defaultAll()
def createGame(self, rows=(7, 7, 7, 5)): # create layout l, s = Layout(self), self.s # set window w, h = l.XM+max( max(rows)*(l.XS+3*l.XOFFSET), 9*l.XS), l.YM+(len(rows)+2)*l.YS self.setSize(w, h) # create stacks x, y = l.XM+(w-l.XM-8*l.XS)//2, 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, base_rank=KING, suit=i, dir=-1)) x += l.XS n = 0 y = l.YM+l.YS for i in rows: x = l.XM for j in range(i): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) x += l.XS+3*l.XOFFSET n += 1 y += l.YS x, y = l.XM+(w-l.XM-8*l.XS)//2, h-l.YS for i in range(8): s.reserves.append(ReserveStack(x, y, self)) x += l.XS s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self) # default l.defaultAll()
def createGame(self, rows=3): # 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) + l.TEXT_HEIGHT, (4 * l.YOFFSET)) 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 font = self.app.getFont("canvas_default") for i in range(rows): stack = BasicRowStack(x, y, self, max_cards=5, max_accept=0, max_move=1) 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 = Knockout_Talon(x, y, self, max_rounds=3) l.createText(s.talon, 'ne') l.createRoundText(s.talon, 's') y = y + l.YS + l.TEXT_HEIGHT s.foundations.append( Knockout_Foundation(x, y, self, max_move=0, base_rank=ANY_RANK, suit=self.FOUNDATION_SUIT)) l.createText(s.foundations[0], 'se') # define stack-groups l.defaultStackGroups() return l
def createGame(self, rows=4): # create layout max_rows = max(10, 4+rows) l, s = Layout(self), self.s # set window w, h = l.XM+max_rows*l.XS, l.YM+2*l.YS+18*l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM, l.YM s.talon = GrandDuchess_Talon(x, y, self, max_rounds=4) l.createText(s.talon, 'se') l.createRoundText(s.talon, 'ne') x += 2*l.XS 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 x, y = l.XM+(max_rows-rows)*l.XS//2, l.YM+l.YS for i in range(rows): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) stack.CARD_YOFFSET = l.YOFFSET s.rows.append(stack) x += l.XS dx = (max_rows-rows)*l.XS//4-l.XS//2 x, y = l.XM+dx, l.YM+l.YS s.reserves.append(GrandDuchess_Reserve(x, y, self)) x, y = self.width-dx-l.XS, l.YM+l.YS s.reserves.append(GrandDuchess_Reserve(x, y, self)) # define stack-groups l.defaultStackGroups()
def createGame(self, rows=4): # create layout max_rows = max(10, 4 + rows) l, s = Layout(self), self.s # set window w, h = l.XM + max_rows * l.XS, l.YM + 2 * l.YS + 18 * l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM, l.YM s.talon = GrandDuchess_Talon(x, y, self, max_rounds=4) l.createText(s.talon, 'se') l.createRoundText(s.talon, 'ne') x += 2 * l.XS 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 x, y = l.XM + (max_rows - rows) * l.XS // 2, l.YM + l.YS for i in range(rows): stack = BasicRowStack(x, y, self, max_move=1, max_accept=0) stack.CARD_YOFFSET = l.YOFFSET s.rows.append(stack) x += l.XS dx = (max_rows - rows) * l.XS // 4 - l.XS // 2 x, y = l.XM + dx, l.YM + l.YS s.reserves.append(GrandDuchess_Reserve(x, y, self)) x, y = self.width - dx - l.XS, l.YM + l.YS s.reserves.append(GrandDuchess_Reserve(x, y, self)) # define stack-groups l.defaultStackGroups()
def canMoveCards(self, cards): if not BasicRowStack.canMoveCards(self, cards): return False c1 = cards[0] for c2 in cards[1:]: if c1.suit != c2.suit: return False # check the rank - an ACE equals a Six rank = c1.rank if rank == ACE: rank = 5 if (rank + self.cap.dir) % self.cap.mod != c2.rank: return False c1 = c2 return True
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if self.id % 10 != 0: # left neighbour s = self.game.s.rows[self.id - 1] if s.cards and s.cards[-1].suit == cards[0].suit \ and (s.cards[-1].rank + 1) % 13 == cards[0].rank: return True if self.id % 10 != 10 - 1: # right neighbour s = self.game.s.rows[self.id + 1] if s.cards and s.cards[-1].suit == cards[0].suit \ and (s.cards[-1].rank - 1) % 13 == cards[0].rank: return True return False
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if self.id % self.game.RSTEP == 0: return cards[0].rank == self.game.RBASE r = self.game.s.rows left = r[self.id - 1] if left.cards and left.cards[-1].suit == cards[0].suit \ and left.cards[-1].rank + 1 == cards[0].rank: return True if self.id < len(r)-1: right = r[self.id + 1] if right.cards and right.cards[-1].suit == cards[0].suit \ and right.cards[-1].rank - 1 == cards[0].rank: return True return False
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False # left neighbour s = self.game.s.rows[(self.id - 1) % 54] if s.cards: if s.cards[-1].suit == cards[0].suit and \ s.cards[-1].rank + 1 == cards[0].rank: return True if s.cards[-1].rank == QUEEN and cards[0].rank == ACE: return True # right neighbour s = self.game.s.rows[(self.id + 1) % 54] if s.cards: if s.cards[-1].suit == cards[0].suit and \ s.cards[-1].rank - 1 == cards[0].rank: return True return False
def createGame(self, rows=8): # create layout l, s = Layout(self), self.s # set window w, h = l.XM + (rows + 2) * l.XS, max( l.YM + 3 * l.XS + 10 * l.YOFFSET, l.YM + 2 * l.YS + self.RESERVE_CARDS * l.YOFFSET + l.TEXT_HEIGHT) self.setSize(w, h) # create stacks y = l.YM for i in range(4): x = l.XM + (rows - 8) * l.XS // 2 + i * l.XS s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) x = l.XM + (rows // 2 + 2) * l.XS + i * l.XS s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) x, y = l.XM + rows * l.XS // 2, l.YM s.reserves.append(Backbone_BraidStack(x, y, self, max_accept=0)) x += l.XS s.reserves.append(Backbone_BraidStack(x, y, self, max_accept=0)) x, y = l.XM + (rows + 1) * l.XS // 2, l.YM + self.RESERVE_CARDS * l.YOFFSET s.reserves.append(BasicRowStack(x, y, self, max_accept=0)) x, y = l.XM, l.YM + l.YS for i in range(rows // 2): s.rows.append(SS_RowStack(x, y, self, max_move=1)) x += l.XS x, y = l.XM + (rows // 2 + 2) * l.XS, l.YM + l.YS for i in range(rows // 2): s.rows.append(SS_RowStack(x, y, self, max_move=1)) x += l.XS x, y = l.XM + rows * l.XS // 2, h - 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): l, s = Layout(self), self.s self.setSize(l.XM+6*l.XS, l.YM+2*l.YS+12*l.YOFFSET) x, y, = l.XM, l.YM s.talon = self.Talon_Class(x, y, self) l.createText(s.talon, "s") x, y = l.XM+2*l.XS, l.YM for i in range(4): s.foundations.append(Formic_Foundation(x, y, self, suit=ANY_SUIT, base_rank=ANY_RANK, max_cards=52, max_move=0)) x += l.XS x, y = l.XM+2*l.XS, l.YM+l.YS for i in range(4): s.rows.append(BasicRowStack(x, y, self, max_move=1, max_accept=0)) x += l.XS l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = l.XM + 12 * l.XS, l.YM + 2 * l.YS + 2 * (l.YS + 5 * l.YOFFSET) self.setSize(w, h) # create stacks y = l.YM + 2 * l.YS for i in range(2): x = l.XM for j in range(12): s.rows.append(BasicRowStack(x, y, self, max_accept=0)) x += l.XS y += l.YS + 5 * l.YOFFSET x = l.XM + 2 * l.XS for j in range(2): for i in range(4): y = l.YM s.foundations.append( SS_FoundationStack(x, y, self, suit=j * 2 + i / 2)) y += l.YS s.foundations.append( SS_FoundationStack(x, y, self, suit=j * 2 + i / 2, base_rank=KING, dir=-1)) x += l.XS s.reserves.append(ReserveStack(l.XM, l.YM, self)) s.reserves.append(ReserveStack(w - l.XS, l.YM, self)) s.talon = InitialDealTalonStack(l.XM, l.YM + l.YS, self) # default l.defaultAll()
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True return from_stack is self.game.s.waste and len(cards) == 1
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False # this stack accepts any one card from the Waste pile return from_stack is self.game.s.waste
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False return from_stack not in self.game.s.rows
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False # this stack accepts any one card from reserves return from_stack in self.game.s.reserves
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return False # this stack accepts any one card from the Talon return from_stack is self.game.s.talon and len(cards) == 1
def canMoveCards(self, cards): if self.game.s.talon.cards: return False return BasicRowStack.canMoveCards(self, cards)
def doubleclickHandler(self, event): if self.game.s.talon.cards: self.game.s.talon.playMoveMove(1, self) return 1 return BasicRowStack.doubleclickHandler(self, event)
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return 0 # check return not (self.cards or self.game.s.talon.cards)
def acceptsCards(self, from_stack, cards): if not BasicRowStack.acceptsCards(self, from_stack, cards): return 0 if not self.cards: return 1 return self.cards[-1].rank > cards[0].rank