def __init__(self, x, y, game): RK_FoundationStack.__init__(self, x, y, game, base_rank=ACE, dir=0, max_move=0, max_cards=8) self.CARD_YOFFSET = min(30, self.game.app.images.CARD_YOFFSET + 10)
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 7 * l.XS, l.YM + 4 * l.YS) x, y = l.XM, l.YM s.talon = WasteTalonStack(x, y, self, max_rounds=3) 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') x0, y0 = l.XM + 2 * l.XS, l.YM k = 0 for i, j in ((2, 0), (0, 1.5), (4, 1.5), (2, 3)): x, y = x0 + i * l.XS, y0 + j * l.YS s.foundations.append( RK_FoundationStack( x, y, self, # suit=ANY_SUIT, base_rank=KING, dir=-1, max_move=0)) k += 1 k = 0 for i, j in ((2, 1), (1, 1.5), (3, 1.5), (2, 2)): x, y = x0 + i * l.XS, y0 + j * l.YS s.foundations.append( RK_FoundationStack( x, y, self, # suit=ANY_SUIT, base_rank=1, max_move=0, max_cards=12)) k += 1 k = 0 for i, j in ((1, 0.2), (3, 0.2), (1, 2.8), (3, 2.8)): x, y = x0 + i * l.XS, y0 + j * l.YS s.foundations.append( IdleAces_AceFoundation(x, y, self, suit=k, max_cards=1, max_move=0)) k += 1 l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False if from_stack not in self.game.s.rows: return False row_id = self.id + 8 return len(self.game.allstacks[row_id].cards) > 0
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 10 * l.XS, l.YM + 2 * l.YS + 12 * l.YOFFSET + l.TEXT_HEIGHT) 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(8): s.foundations.append( SS_FoundationStack(x, y, self, suit=i % 4, max_cards=12)) x += l.XS x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT s.foundations.append( RK_FoundationStack(x, y, self, suit=ANY_SUIT, base_rank=KING, dir=0, max_cards=8)) x += 3 * l.XS for i in range(6): s.rows.append(RK_RowStack(x, y, self, max_move=1)) x += l.XS l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+7*l.XS, l.YM+3*l.YS) for i, j in ((1, 0), (2, 0), (3, 0), (4, 0), (5, 1), (3.5, 2), (2.5, 2), (1.5, 2), (0, 1), ): x, y = l.XM+(1+i)*l.XS, l.YM+j*l.YS stack = CircleNine_RowStack(x, y, self, max_accept=1, max_move=1, base_rank=NO_RANK) s.rows.append(stack) stack.CARD_YOFFSET = 0 x, y = l.XM+3.5*l.XS, l.YM+l.YS stack = RK_FoundationStack(x, y, self, suit=ANY_SUIT, max_cards=52, max_move=0, mod=13, base_rank=ANY_RANK) s.foundations.append(stack) l.createText(stack, 'ne') x, y = l.XM, l.YM s.talon = Strategerie_Talon(x, y, self) l.createText(s.talon, 'ne') l.defaultStackGroups() self.sg.dropstacks.append(s.talon)
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 createGame(self, rows=5, reserves=4, playcards=15): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 8 * l.XS, l.YM + 3 * l.YS + playcards * l.YOFFSET) # create stacks x, y = l.XM, l.YM for i in range(4): for j in range(2): s.foundations.append( RK_FoundationStack(x, y, self, suit=ANY_SUIT)) x += l.XS x, y = l.XM + (8 - rows) * l.XS // 2, l.YM + l.YS for i in range(rows): s.rows.append(Gloaming_RowStack(x, y, self, max_accept=1)) x += l.XS x, y = l.XM + (8 - reserves - 1) * l.XS // 2, self.height - l.YS for i in range(reserves): s.reserves.append(OpenStack(x, y, self, max_accept=0)) x += l.XS s.talon = TalonStack(x, y, self) l.createText(s.talon, 'n') # define stack-groups 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): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 10 * l.XS, l.YM + 5 * l.YS) # create stacks x, y, = l.XM + 3 * l.XS, l.YM for i in range(4): s.foundations.append(RK_FoundationStack(x, y, self, max_move=0)) x += l.XS for i in range(2): y = l.YM + (i * 2 + 3) * l.YS / 2 for j in range(4): x = l.XM + (j * 5) * l.XS / 2 stack = RK_RowStack(x, y, self, base_rank=NO_RANK, max_move=1) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) x, y, = l.XM + 3 * l.XS, l.YM + 4 * l.YS s.talon = Bristol_Talon(x, y, self) l.createText(s.talon, "sw") x += l.XS for i in range(3): stack = WasteStack(x, y, self) l.createText(stack, 'n') s.reserves.append(stack) x += l.XS # define stack-groups self.sg.openstacks = s.foundations + s.rows self.sg.talonstacks = [s.talon] self.sg.dropstacks = s.rows + s.reserves
def createGame(self, rows=8): # create layout layout, s = Layout(self), self.s # set window playcards = 12 self.setSize( layout.XM+rows*layout.XS, layout.YM+3*layout.YS+playcards*layout.YOFFSET) # create stacks x, y = layout.XM + (rows-1)*layout.XS//2, layout.YM stack = RK_FoundationStack(x, y, self, base_rank=ANY_RANK, max_cards=52, mod=13) s.foundations.append(stack) layout.createText(stack, 'ne') x, y = layout.XM, layout.YM+layout.YS for i in range(rows): s.rows.append(RK_RowStack(x, y, self, base_rank=NO_RANK, mod=13)) x += layout.XS x, y = layout.XM, self.height-layout.YS s.talon = TalonStack(x, y, self) layout.createText(s.talon, 'se') # define stack-groups layout.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False if len(self.cards) == 12: # the final card must come from the reserve above the foundation return from_stack.id == self.id - 8 else: # card must come from rows return from_stack in self.game.s.rows
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False if self.cards: return True if self.game.s.reserves[0].cards: c = self.game.s.reserves[0].cards[-1] return (c.rank+1) % 13 == cards[-1].rank return True
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False c = cards[0] if c.rank in (4, 5): i = list(self.game.s.foundations).index(self) % 8 r = self.game.s.rows[i] if not r.cards: return False return True
def createGame(self, rows=4, 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 + (3 * l.YS)) # create stacks x, y = l.XM, l.YM for i in range(2): stack = OpenStack(x, y, self) stack.CARD_XOFFSET = l.XOFFSET l.createText(stack, "sw") s.reserves.append(stack) x += 4.5 * l.XS x, y = l.XM, y + l.YS for i in range(4): s.foundations.append( RK_FoundationStack(x, y, self, suit=i, base_rank=ACE, dir=1)) x = x + l.XS x = x + (l.XS / 2) for i in range(4): s.foundations.append( RK_FoundationStack(x, y, self, suit=i, base_rank=KING, dir=-1)) x = x + l.XS x, y = l.XM + l.XS, y + l.YS 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 += 2.5 * l.XS for i in range(rows): s.rows.append(AcesAndKings_RowStack(x, y, self, max_accept=1)) x = x + l.XS # define stack-groups l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False # check the suit num_cards = len(self.cards) for f in self.game.s.foundations: if len(f.cards) > num_cards: suit = f.cards[num_cards].suit break else: return True return cards[0].suit == suit
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False if from_stack in self.game.s.rows: ri = list(self.game.s.rows).index(from_stack) fi = list(self.game.s.foundations).index(self) if ri < 4: return ri == fi if ri == 4: return True return ri-1 == fi return False
def acceptsCards(self, from_stack, cards): if (not self.cards): if (self.id > 0 and not self.game.s .foundations[self.id - 1].cards): return False if self.id == 0: return cards[0].rank == KING else: return cards[0].rank == (self.game.s .foundations[self.id - 1] .cards[0].rank - 1) % 13 if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False return True
def acceptsCards(self, from_stack, cards): if len(cards) > 1: return False if len(self.cards) > 0: return (self.cards[-1].suit == cards[0].suit and RK_FoundationStack.acceptsCards(self, from_stack, cards)) foundations = self.game.s.foundations for i in range(4): if (foundations[i].cards and foundations[i].cards[0].suit == cards[0].suit): return False if cards[0].rank != self.cap.base_rank: return False return True
def createGame(self, **layout): # create layout l, s = Layout(self), self.s l.freeCellLayout(rows=4, reserves=4, texts=1) self.setSize(l.size[0], l.size[1]) # create stacks s.talon = Strategerie_Talon(l.s.talon.x, l.s.talon.y, self) for r in l.s.foundations: s.foundations.append(RK_FoundationStack(r.x, r.y, self)) for r in l.s.rows: s.rows.append(Strategerie_RowStack(r.x, r.y, self, max_accept=UNLIMITED_ACCEPTS)) for r in l.s.reserves: s.reserves.append(Strategerie_ReserveStack(r.x, r.y, self)) # default l.defaultAll() self.sg.dropstacks.append(s.talon)
def createGame(self): # create layout l, s = Layout(self), self.s # set window # (set size so that at least 13 cards are fully playable) w = max(3 * l.XS, l.XS + 13 * l.XOFFSET) self.setSize(l.XM + 2 * w + 2 * l.XS, l.YM + 5 * l.YS + l.TEXT_HEIGHT) # create stacks x, y = l.XM, l.YM + 4 * l.YS s.talon = InitialDealTalonStack(x, y, self) x, y = l.XM + w - l.XS, self.height - l.YS for i in range(4): stack = OpenStack(x, y, self, max_accept=0) s.reserves.append(stack) l.createText(stack, 'n') x += l.XS x = l.XM + w for x in (l.XM + w, l.XM + w + l.XS): y = l.YM for i in range(4): s.foundations.append(RK_FoundationStack(x, y, self, max_move=0)) y += l.YS for x in (l.XM, l.XM + w + 2 * l.XS): y = l.YM for i in range(4): stack = RK_RowStack(x, y, self, max_move=1, max_accept=1, base_rank=ANY_RANK) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 s.rows.append(stack) y += l.YS l.setRegion(s.rows[:4], (-999, -999, w - l.CW // 2, l.YM + 4 * l.YS - l.CH // 2)) # define stack-groups l.defaultStackGroups() # set regions l.defaultRegions()
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, rows=8): # create layout l, s = Layout(self), self.s # set size self.setSize(l.XM + (rows+2)*l.XS, l.YM + 5*l.YS) # playcards = 4*l.YS // l.YOFFSET xoffset, yoffset = [], [] for i in range(playcards): xoffset.append(0) yoffset.append(l.YOFFSET) for i in range(104-playcards): xoffset.append(l.XOFFSET) yoffset.append(0) # create stacks x, y = l.XM, l.YM for i in range(rows): stack = RK_RowStack(x, y, self) stack.CARD_XOFFSET = xoffset stack.CARD_YOFFSET = yoffset s.rows.append(stack) x += l.XS x, y = l.XM + rows*l.XS, l.YM for suit in range(4): for i in range(2): s.foundations.append(RK_FoundationStack(x+i*l.XS, y, self, suit=suit)) y += l.YS self.setRegion(self.s.foundations, (x - l.CW // 2, -999, 999999, y), priority=1) x, y = self.width-3*l.XS//2, self.height-l.YS s.talon = InitialDealTalonStack(x, y, self) # define stack-groups l.defaultStackGroups()
def acceptsCards(self, from_stack, cards): if len(self.cards) > 0: return (self.cards[-1].suit == cards[0].suit and RK_FoundationStack.acceptsCards( self, from_stack, cards)) foundations = self.game.s.foundations # Checking each rule for starting a new foundation: # Only the next foundation can be built to. if self.id > 0 and len(foundations[self.id - 1].cards) == 0: return False # The suit must match the foundation directly to the left. if (self.id > 3 and foundations[self.id - 4].cards[0].suit != cards[0].suit): return False # Two foundations in the same column can't have the same suit. if self.id <= 3: for i in range(4): if (foundations[i].cards and foundations[i].cards[0].suit == cards[0].suit): return False # Only the lowest available card of a suit can start a foundation. for row in self.game.s.rows: if (row.cards and row.cards[-1].suit == cards[0].suit and row.cards[-1].rank < cards[0].rank): return False # Can't start a foundation with a card that can be played on an # existing foundation. for foundation in foundations: if (foundation.cards and foundation.cards[-1].suit == cards[0].suit and (foundation.cards[-1].rank == cards[0].rank - 1 or (foundation.cards[-1].rank == KING and cards[0].rank == ACE))): return False return True
def acceptsCards(self, from_stack, cards): if not RK_FoundationStack.acceptsCards(self, from_stack, cards): return False if (self.id > 0 and not self.game.s.foundations[self.id - 1].cards): return False return True
def __init__(self, x, y, game): RK_FoundationStack.__init__( self, x, y, game, base_rank=ACE, dir=0, max_move=0, max_cards=8) self.CARD_YOFFSET = min(30, self.game.app.images.CARD_YOFFSET + 10)
def getBottomImage(self): if self.cap.base_rank == ACE: return self.game.app.images.getLetter(ACE) return RK_FoundationStack.getBottomImage(self)