def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 5.5 * l.XS, l.YM + 4 * l.YS) x, y = l.XM, l.YM + l.YS s.talon = WasteTalonStack(x, y, self, max_rounds=3) l.createText(s.talon, 'ne') l.createRoundText(s.talon, 'nn') y += l.YS s.waste = WasteStack(x, y, self) l.createText(s.waste, 'ne') x, y = l.XM + 1.5 * l.XS, l.YM for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, max_cards=13)) x += l.XS x = l.XM + 1.5 * l.XS y += l.YS for i in range(4): s.rows.append( AbstractFoundationStack(x, y, self, suit=i, max_cards=1, max_move=0, base_rank=QUEEN)) x += l.XS x = l.XM + 1.5 * l.XS y += l.YS for i in range(4): s.rows.append( AbstractFoundationStack(x, y, self, suit=i, max_cards=1, max_move=0, base_rank=JACK)) x += l.XS x = l.XM + 1.5 * l.XS y += l.YS for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, mod=13, max_cards=11, base_rank=9, dir=-1)) x += l.XS l.defaultStackGroups()
def __init__(self, x, y, game, suit, **cap): kwdefault(cap, max_cards=12, max_move=0, base_rank=ANY_RANK, base_suit=ANY_SUIT) AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True dir = self._getDir() return (self.cards[-1].rank + dir) % self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True dir = self._getDir() return (self.cards[-1].rank+dir) % self.cap.mod == cards[0].rank
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 createGame(self, rows=6, texts=True): l, s = Layout(self), self.s max_rows = max(8, rows) self.setSize(l.XM + max_rows * l.XS, l.YM + 2 * l.YS + 13 * l.YOFFSET) x, y = l.XM + l.XS * (max_rows - 4) // 2, l.YM for i in range(4): s.reserves.append(ReserveStack(x, y, self)) x += l.XS x = l.XM + (max_rows - 1) * l.XS s.foundations.append( AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_cards=52, max_accept=0)) l.createText(s.foundations[0], 'nw') x, y = l.XM + l.XS * (max_rows - rows) // 2, l.YM + l.YS for i in range(rows): s.rows.append(UD_AC_RowStack(x, y, self, mod=13)) x += l.XS s.talon = self.Talon_Class(l.XM, l.YM, self) if texts: l.createText(s.talon, 'ne') l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+6*l.XS, 2*l.YM+2*l.YS+6*l.YOFFSET) # create stacks for i in range(2): for j in range(4): x, y = l.XM + j*l.XS, l.YM+i*(l.YM+l.YS+3*l.YOFFSET) s.rows.append(Nestor_RowStack(x, y, self, max_move=1, max_accept=1, dir=0, base_rank=NO_RANK)) x, y = self.width - l.XS, l.YM s.talon = InitialDealTalonStack(x, y, self) x, y = self.width - l.XS, self.height - l.YS s.foundations.append( AbstractFoundationStack( x, y, self, suit=ANY_SUIT, max_move=0, max_cards=32, max_accept=0, base_rank=ANY_RANK)) l.createText(s.foundations[0], "n") # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout layout, s = Layout(self), self.s # set window h1 = layout.YS+5*layout.YOFFSET self.setSize(layout.XM+7*layout.XS, layout.YM+2*h1+layout.YS) # create stacks y = layout.YM for i in (0, 1): x = layout.XM for j in range(5): stack = Exit_RowStack(x, y, self, base_rank=NO_RANK, max_move=1, max_accept=1, dir=0) s.rows.append(stack) stack.CARD_YOFFSET = layout.YOFFSET x += layout.XS y += h1 x, y = self.width-layout.XS, layout.YM stack = Exit_RowStack(x, y, self, base_rank=NO_RANK, max_move=1, max_accept=1, dir=0) s.reserves.append(stack) stack.CARD_YOFFSET = layout.YOFFSET 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") x, y = layout.XM, self.height-layout.YS s.talon = InitialDealTalonStack(x, y, self) # define stack-groups layout.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+5*l.XS, l.YM+3*l.YS) # create stacks x, y = l.XM+l.XS, l.YM+2*l.YS s.talon = RightAndLeft_Talon(x, y, self, max_rounds=UNLIMITED_REDEALS) l.createText(s.talon, 'se') x, y = l.XM+0.5*l.XS, l.YM for i in range(2): stack = Nestor_RowStack(x, y, self, max_move=1, max_accept=1, dir=0, base_rank=NO_RANK) stack.CARD_YOFFSET = 0 l.createText(stack, 's') s.rows.append(stack) x += l.XS x += 1.5*l.XS s.foundations.append(AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_move=0, max_cards=104, max_accept=0, base_rank=ANY_RANK)) l.createText(s.foundations[0], 's') # define stack-groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 12 * l.XS, l.YM + 3 * l.YS + 3 * l.YOFFSET) x, y = l.XM, l.YM for i in range(12): s.rows.append( Nestor_RowStack(x, y, self, max_move=1, max_accept=1, dir=0, base_rank=NO_RANK)) x += l.XS x, y = l.XM, self.height - l.YS s.talon = TalonStack(x, y, self) l.createText(s.talon, 'n') x, y = self.width - l.XS, self.height - l.YS s.foundations.append( AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_move=0, max_cards=52, base_rank=ANY_RANK, max_accept=0)) l.createText(s.foundations[0], "n") l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = l.XM + 12 * l.XS, l.YM + l.YS + 16 * l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM, l.YM s.talon = DealRowTalonStack(x, y, self) l.createText(s.talon, "s") x += l.XS for i in range(10): stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK, max_move=UNLIMITED_MOVES, max_accept=UNLIMITED_ACCEPTS) s.rows.append(stack) x += l.XS s.foundations.append( AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_accept=0, max_cards=104)) l.createText(s.foundations[0], "s") # define stack-groups l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False # check the rank if self.cards: r1, r2 = self.cards[-1].rank, cards[0].rank return (r1 + 1) % self.cap.mod == r2 return True
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False if self.cards: # check the rank if (2 * self.cards[-1].rank + 1) % self.cap.mod != cards[0].rank: return False return True
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False # check the rank if len(self.cards) > 12: return cards[0].rank == 25 - len(self.cards) else: return cards[0].rank == len(self.cards)
def createGame(self): layout, s = Layout(self), self.s self.setSize( layout.XM + 9 * layout.XS, layout.YM + 3 * layout.YS + 7 * layout.YOFFSET + 2 * layout.TEXT_HEIGHT) x, y = layout.XM + 4 * layout.XS, layout.YM stack = DevilsSolitaire_Foundation(x, y, self, suit=ANY_SUIT, base_rank=ANY_RANK, mod=13) tx, ty, ta, tf = layout.getTextAttr(stack, 'nw') font = self.app.getFont('canvas_default') stack.texts.misc = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font) s.foundations.append(stack) x, y = self.width - layout.XS, layout.YM stack = AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_move=0, max_cards=104, max_accept=0, base_rank=ANY_RANK) layout.createText(stack, 'nw') s.foundations.append(stack) x, y = layout.XM, layout.YM + layout.YS for i in range(4): s.rows.append(Vague_RowStack(x, y, self)) x += layout.XS x += layout.XS for i in range(4): s.rows.append(Vague_RowStack(x, y, self)) x += layout.XS x, y = layout.XM + 4 * layout.XS, layout.YM + layout.YS stack = OpenStack(x, y, self) stack.CARD_YOFFSET = layout.YOFFSET s.reserves.append(stack) x, y = layout.XM + 4.5 * layout.XS, self.height - layout.YS s.talon = WasteTalonStack(x, y, self, max_rounds=3) layout.createText(s.talon, 'n') layout.createRoundText(s.talon, 'nnn') x -= layout.XS s.waste = DevilsSolitaire_WasteStack(x, y, self) layout.createText(s.waste, 'n') layout.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False c = cards[0] for s in self.game.s.rows: if s is not from_stack and s.cards and s.cards[-1].suit == c.suit: if s.cards[-1].rank > c.rank or s.cards[-1].rank == ACE: # found a higher rank or an Ace on the row stacks return c.rank != ACE return False
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False if self.game.base_rank is None: return True if not self.cards: return cards[-1].rank == self.game.base_rank # check the rank return (self.cards[-1].rank + self.cap.dir) % \ self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.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 createGame(self): # create layout l, s = Layout(self), self.s # set window ww = l.XS + max(2 * l.XOFFSET, l.XS // 2) w = l.XM + 1.5 * l.XS + 4 * ww h = l.YM + 3 * l.YS self.setSize(w, h) # create stacks for xx, yy in ( (0, 0), (1, 0), (2, 0), (3, 0), (0, 1), (3, 1), (0, 2), (1, 2), (2, 2), (3, 2), ): x, y = l.XM + 1.5 * l.XS + ww * xx, l.YM + l.YS * yy stack = Hurricane_Reserve(x, y, self, max_accept=1) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.reserves.append(stack) d = 3 * ww - 4 * l.XS - 2 * l.XOFFSET x = l.XM + 1.5 * l.XS + l.XS + 2 * l.XOFFSET + d // 2 y = l.YM + l.YS for i in range(3): stack = Hurricane_RowStack(x, y, self, max_accept=1) s.rows.append(stack) x += l.XS x, y = l.XM, l.YM s.talon = TalonStack(x, y, self) l.createText(s.talon, 'ne') y += 2 * l.YS s.foundations.append( AbstractFoundationStack(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], 'ne') # define stack-groups l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return 0 if not self.cards: return cards[0].suit == self.game.base_card.suit stack_dir = self.game.getFoundationDir() if stack_dir == 0: card_dir = (cards[0].suit - self.cards[-1].suit) % 12 return card_dir in (1, 11) else: return (self.cards[-1].suit + stack_dir) % 12 == cards[0].suit
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True stack_dir = self.game.getFoundationDir() if stack_dir == 0: card_dir = self.getRankDir(cards=(self.cards[-1], cards[0])) return card_dir in (1, -1) else: return ((self.cards[-1].rank + stack_dir) % self.cap.mod == cards[0].rank)
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return 0 if not self.cards: return 1 stack_dir = self.game.getFoundationDir() if stack_dir == 0: card_dir = (cards[0].rank - self.cards[-1].rank) % self.cap.mod return card_dir in (1, 15) else: return (self.cards[-1].rank + stack_dir) % self.cap.mod \ == cards[0].rank
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return 0 if not self.cards: return 1 stack_dir = self.game.getFoundationDir() if stack_dir == 0: card_dir = (cards[0].rank - self.cards[-1].rank) % self.cap.mod return card_dir in (1, 11) else: return (self.cards[-1].rank + stack_dir) % \ self.cap.mod == cards[0].rank
def acceptsCards(self, from_stack, cards): if not (from_stack in self.game.s.rows and AbstractFoundationStack.acceptsCards(self, from_stack, cards)): return 0 pile, rank, suit = from_stack.getPile(), 0, 0 if self.cards: rank = (self.cards[-1].rank + 1) % 12 suit = self.cards[-1].suit + (rank == 0) if (not pile or len(pile) <= 11 - rank or not isSameSuitSequence(pile[-(12 - rank):])): return 0 return cards[0].suit == suit and cards[0].rank == rank
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False # check the rank # 7, 8, 9, 10, J, Q, K, A, K, Q, J, 10, 9, 8, 7, A if len(self.cards) < 7: return cards[0].rank - 6 == len(self.cards) elif len(self.cards) == 7: return cards[0].rank == ACE elif len(self.cards) < 15: return cards[0].rank == 20 - len(self.cards) else: # len(self.cards) == 15 return cards[0].rank == ACE
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False c1 = cards[0] if not self.cards: return c1.rank == ACE and c1.suit == 0 c2 = self.cards[-1] if c2.rank == KING: suit = (c2.suit+1) % 4 rank = ACE else: suit = c2.suit rank = c2.rank+1 return c1.suit == suit and c1.rank == rank
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False # search foundation with max number of cards assert len(cards) == 1 max_s, max_cards = None, -1 for s in self.game.s.foundations: if len(s.cards) > max_cards: max_s, max_cards = s, len(s.cards) # if we have less cards, then rank must match the card in this # foundation if len(self.cards) < max_cards: if cards[0].rank != max_s.cards[len(self.cards)].rank: return False # return True
def createGame(self): # create layout l, s = Layout(self), self.s # set window n = m = max(self.ROWS) if self.ROWS[0] == m or self.ROWS[-1] == m: n = n + 1 self.setSize(l.XM + n * l.XS, l.YM + len(self.ROWS) * l.YS) # game extras 1) self.map = {} # create stacks for i in range(len(self.ROWS)): r = self.ROWS[i] for j in range(r): d = m - r + 2 * j x, y = l.XM + d * l.XS // 2, l.YM + i * l.YS stack = Pegged_RowStack(x, y, self) stack.pos = (d, 2 * i) # print stack.id, stack.pos s.rows.append(stack) self.map[stack.pos] = stack x, y = self.width - l.XS, l.YM s.foundations.append( AbstractFoundationStack(x, y, self, ANY_SUIT, max_move=0, max_accept=0, max_cards=self.gameinfo.ncards)) l.createText(s.foundations[0], "s") y = self.height - l.YS s.talon = InitialDealTalonStack(x, y, self) s.internals.append(InvisibleStack(self)) # game extras 2) self.STEP_MAP = {} for step in self.STEPS: self.STEP_MAP[step] = 1 if self.EMPTY_STACK_ID < 0: self.EMPTY_STACK_ID = len(s.rows) // 2 # Define stack groups l.defaultStackGroups()
def createGame(self, rows=3, cols=3, reserves=3, texts=False): l, s = Layout(self), self.s self.setSize(l.XM + (cols + 2) * l.XS, l.YM + (rows + 1.5) * l.YS) x, y = self.width - l.XS, l.YM s.talon = TalonStack(x, y, self) l.createText(s.talon, 's') x, y = self.width - l.XS, self.height - l.YS s.foundations.append( AbstractFoundationStack(x, y, self, suit=ANY_SUIT, max_accept=0, max_move=0, max_cards=52)) l.createText(s.foundations[0], 'n') y = l.YM for i in range(rows): x = l.XM for j in range(cols): s.rows.append(self.RowStack_Class(x, y, self, max_accept=1)) x += l.XS y += l.YS x, y = l.XM, self.height - l.YS for i in range(reserves): stack = self.Reserve_Class(x, y, self) s.reserves.append(stack) stack.CARD_XOFFSET = l.XOFFSET # for fifteens x += l.XS if texts: stack = s.reserves[0] tx, ty, ta, tf = l.getTextAttr(stack, "n") font = self.app.getFont("canvas_default") stack.texts.misc = MfxCanvasText(self.canvas, tx, ty, anchor=ta, font=font) l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False if from_stack not in self.game.s.rows: return False if cards[0].rank == ACE: return True if not self.cards: return False rank = self.cards[-1].rank if rank == ACE: rank = 5 if (rank + self.cap.dir) % self.cap.mod != cards[0].rank: return False if cards[0].rank == QUEEN: return True i = list(self.game.s.foundations).index(self) j = list(self.game.s.rows).index(from_stack) return i == j
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False assert len(cards) == 1 indx = list(self.game.s.foundations).index(self) c0 = cards[0] below_found = self.game.s.foundations[indx-1] if indx == 0: if not self.cards: return True return c0.suit == self.cards[0].suit if not below_found.cards: return False if not self.cards: return c0.rank == below_found.cards[0].rank if c0.suit != self.cards[0].suit: return False for c1 in below_found.cards: if c0.rank == c1.rank: return True return False
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False # We accept any King. Pairs will get delivered by _dropPairMove. return cards[0].rank == KING
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False # check the rank return ((self.cards[-1].rank+1) % 13 == cards[0].rank or (self.cards[-1].rank-1) % 13 == cards[0].rank)
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False return isRankSequence(cards, dir=0)
def __init__(self, x, y, game, suit=ANY_SUIT, **cap): kwdefault(cap, max_move=0, max_accept=0, max_cards=game.NCARDS) AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def __init__(self, x, y, game, suit, **cap): kwdefault(cap, mod=12, dir=0, base_rank=NO_RANK, max_move=0) AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): return False return isSameColorSequence(cards, self.cap.mod, self.cap.dir)
def updateText(self): AbstractFoundationStack.updateText(self) self.game.updateText()
def __init__(self, x, y, game, suit, **cap): kwdefault(cap, base_suit=0, mod=12, max_cards=120, max_move=0) AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def __init__(self, x, y, game, suit, **cap): kwdefault(cap, mod=12, dir=0, base_suit=ANY_SUIT, max_move=0) AbstractFoundationStack.__init__(self, x, y, game, suit, **cap)
def __init__(self, x, y, game, suit, **cap): kwdefault(cap, max_move=0, max_cards=48, max_accept=4, min_accept=4) AbstractFoundationStack.__init__(self, x, y, game, suit, **cap) self.CARD_YOFFSET = self.game.app.images.CARDH // 10