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): # create layout l, s = Layout(self), self.s # set window xx, yy = 9, 6 w, h = l.XM + xx * l.XS, l.YM + 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 + i * l.YS s.rows.append(self.RowStack_Class(x, y, self)) s.talon = PushPin_Talon(l.XM, l.YM, self) 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): # create layout l, s = Layout(self), self.s # set window w = l.XM + 9*l.XS h = l.YM + 5.67*l.YS self.setSize(w, h) # create stacks x, y = l.XM, l.YM s.rows += self._createPyramid(l, x, y, 2) x, y = l.XM+2*l.XS, l.YM s.rows += self._createPyramid(l, x, y, 7) x, y = l.XM+2.5*l.XS, l.YM+3*l.YS s.rows += self._createPyramid(l, x, y, 6) x, y = l.XM, self.height-l.YS s.talon = self.Talon_Class(x, y, self) 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)) l.createText(s.foundations[0], 's') # 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, 3*l.YM+5*l.YS) # create stacks x, y = l.XM, l.YM s.talon = Cone_Talon(x, y, self) l.createText(s.talon, 's') y += l.YS+2*l.YM for i in range(4): s.reserves.append(OpenStack(x, y, self, max_accept=0)) y += l.YS x, y = l.XM+l.XS, l.YM for i in range(7): s.rows.append(AC_RowStack(x, y, self, mod=13)) x += l.XS for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i, mod=13, max_cards=26)) y += l.YS # define stack-groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+8*l.XS, l.YM+max(4*l.YS, 3*l.YS+14*l.YOFFSET)) x, y = l.XM, self.height-l.YS for i in range(4): suit = i if self.Foundation_Class_1 is RK_FoundationStack: suit = ANY_SUIT s.foundations.append(self.Foundation_Class_1(x, y, self, suit=suit)) x += l.XS for i in range(4): suit = i if self.Foundation_Class_1 is RK_FoundationStack: suit = ANY_SUIT s.foundations.append(self.Foundation_Class_2(x, y, self, suit=suit)) x += l.XS x, y = l.XM+2*l.XS, l.YM+l.YS for i in range(4): s.rows.append(LadyOfTheManor_RowStack(x, y, self, max_accept=0)) x += l.XS for i, j in ((0,2), (0,1), (0,0), (1,0), (2,0), (3,0), (4,0), (5,0), (6,0), (7,0), (7,1), (7,2),): x, y = l.XM+i*l.XS, l.YM+j*l.YS s.reserves.append(LadyOfTheManor_Reserve(x, y, self, max_accept=0)) s.talon = InitialDealTalonStack(self.width-l.XS, self.height-2*l.YS, self) l.defaultAll()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+9.5*l.XS, l.YM+4*l.YS) x, y = l.XM+l.XS, l.YM for i in range(8): s.foundations.append(SS_FoundationStack(x, y, self, suit=i%4, base_rank=JACK, dir=-1, max_cards=11)) x += l.XS x, y = l.XM+l.XS, l.YM+l.YS for i in range(8): s.foundations.append(Adela_Foundation(x, y, self, suit=i%4, base_rank=QUEEN, max_cards=1)) x += l.XS x, y = l.XM+l.XS, l.YM+2*l.YS for i in range(8): s.foundations.append(Adela_Foundation(x, y, self, suit=i%4, base_rank=KING, max_cards=1)) x += l.XS x, y = l.XM, l.YM+l.YS s.talon = DealRowTalonStack(x, y, self) l.createText(s.talon, 'n') x, y = l.XM+l.XS/2, l.YM+3*l.YS for i in range(9): stack = SS_RowStack(x, y, self, max_move=1, dir=1) s.rows.append(stack) stack.CARD_YOFFSET = 0 x += l.XS l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+9*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)) y += l.YS x, y = self.width-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 x, y = (self.width-l.XS)/2, self.height-l.YS s.talon = DealRowTalonStack(x, y, self) l.createText(s.talon, 'se') y = l.YM for i in range(4): x = l.XM+l.XS*3/2 for j in range(6): stack = UD_SS_RowStack(x, y, self, base_rank=NO_RANK) s.rows.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0 x += l.XS y += l.YS l.defaultStackGroups()
def createGame(self, rows=13, reserves=10, playcards=20): # create layout l, s = Layout(self), self.s # set window decks = self.gameinfo.decks max_rows = max(decks*4, rows, reserves) w, h = l.XM+max_rows*l.XS, l.YM+3*l.YS+playcards*l.YOFFSET self.setSize(w, h) # create stacks s.talon = self.Talon_Class(l.XM, h-l.YS, self) x, y = l.XM+(max_rows-decks*4)*l.XS//2, l.YM for j in range(4): for i in range(decks): s.foundations.append(self.Foundation_Class(x, y, self, suit=j)) x += l.XS x, y = l.XM+(max_rows-reserves)*l.XS//2, l.YM+l.YS for i in range(reserves): s.reserves.append(ReserveStack(x, y, self)) x += l.XS x, y = l.XM+(max_rows-rows)*l.XS//2, l.YM+2*l.YS for i in range(rows): s.rows.append(self.RowStack_Class(x, y, self)) x += l.XS # default l.defaultAll()
def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = 3*l.XM+10*l.XS, 2*l.YM+2*l.YS+16*l.YOFFSET self.setSize(w, h) # create stacks s.talon = self.Talon_Class(l.XM, h-l.YS, self) x, y = 3*l.XM + 6*l.XS, l.YM for i in range(4): s.foundations.append( self.Foundation_Class( x, y, self, suit=i, mod=13, max_cards=26)) x += l.XS x, y = 2*l.XM, l.YM + l.YS + l.YM for i in range(10): s.rows.append(self.RowStack_Class(x, y, self)) x += l.XS x, y = l.XM, l.YM for i in range(6): s.reserves.append(ReserveStack(x, y, self)) x += l.XS # default l.defaultAll()
def createGame(self, max_rounds=1, num_deal=1, **layout): l, s = Layout(self), self.s kwdefault(layout, rows=8, waste=1) self.Layout_Method(l, **layout) self.setSize(l.size[0], l.size[1]) # Create talon s.talon = self.Talon_Class( 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) # Create foundations for r in l.s.foundations: s.foundations.append( self.Foundation_Class( r.x, r.y, self, r.suit, mod=12, max_cards=12, max_move=self.MAX_MOVE)) # Create row stacks for r in l.s.rows: s.rows.append( self.RowStack_Class( r.x, r.y, self, suit=ANY_SUIT, base_rank=self.BASE_RANK)) # Define stack groups l.defaultAll()
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 createGame(self, rows=8, reserves=6): l, s = Layout(self), self.s w, h = l.XM+(rows+reserves+1)*l.XS, l.YM+3*l.YS+16*l.YOFFSET self.setSize(w, h) x, y = l.XM+(rows+reserves+1-8)*l.XS//2, 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, l.YM+l.YS for i in range(reserves): stack = Headquarters_Reserve(x, y, self, max_cards=UNLIMITED_CARDS, max_accept=UNLIMITED_CARDS, max_move=UNLIMITED_CARDS) s.reserves.append(stack) stack.CARD_YOFFSET = l.YOFFSET x += l.XS x, y = l.XM+(reserves+1)*l.XS, l.YM+l.YS for j in range(rows): s.rows.append(AC_RowStack(x, y, self, base_rank=NO_RANK)) x += l.XS x, y = w-l.XS, h-l.YS s.talon = InitialDealTalonStack(x, y, self) l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+8*l.XS, l.YM+5*l.YS) # create stacks x, y = l.XM, l.YM for i in range(8): s.foundations.append(SS_FoundationStack(x, y, self, suit=i/2, max_cards=10)) x += l.XS y = l.YM+l.YS for i in range(3): x = l.XM for j in range(8): ##stack = SS_RowStack(x, y, self, max_move=1) stack = ReserveStack(x, y, self) stack.CARD_YOFFSET = 0 s.rows.append(stack) x += l.XS y += l.YS x, y = self.width-l.XS, self.height-l.YS s.talon = DealRowTalonStack(x, y, self) l.createText(s.talon, 'sw') # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s self.setSize(l.XM+8*l.XS, l.YM+2*l.YS+16*l.YOFFSET) # create stacks x, y = l.XM, l.YM s.talon = DealRowTalonStack(x, y, self) l.createText(s.talon, "s") x += 2*l.XS s.reserves.append(ReserveStack(x, y, self)) x += 2*l.XS for i in range(4): s.foundations.append(Spider_SS_Foundation(x, y, self, suit=ANY_SUIT)) x += l.XS x, y = l.XM+l.XS, l.YM+l.YS for i in range(7): s.rows.append(Spider_RowStack(x, y, self, base_rank=ANY_RANK)) x += l.XS # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window h1 = l.YS+5*l.YOFFSET self.setSize(l.XM+7*l.XS, l.YM+2*h1+l.YS) # create stacks y = l.YM for i in (0, 1): x = l.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 = l.YOFFSET x += l.XS y += h1 x, y = self.width-l.XS, l.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 = l.YOFFSET 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") x, y = l.XM, self.height-l.YS s.talon = InitialDealTalonStack(x, y, self) # define stack-groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s # Set window size self.setSize(l.XM * 3 + l.XS * 9, l.YM + l.YS * 6) # Create row stacks x = l.XM y = l.YM for i in range(8): s.rows.append(RK_RowStack(x, y, self, base_rank=11, max_move=12, max_cards=99)) x = x + l.XS # Create reserve stacks x = self.width - l.XS y = l.YM for i in range(6): s.reserves.append(ReserveStack(x, y, self)) y = y + l.YS y = y - l.YS for i in range(4): x = x - l.XS s.reserves.append(ReserveStack(x, y, self)) self.setRegion(s.rows, (0, 0, l.XM + l.XS * 8, l.YS * 5)) # Create talon s.talon = DealRowTalonStack(l.XM, self.height - l.YS, self) l.createText(s.talon, "n") # Define stack groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+7*l.XS, l.YM+2*l.YS+12*l.YOFFSET) x, y = l.XM, l.YM for i in range(2): s.reserves.append(OpenStack(x, y, self)) x += l.XS x, y = l.XM+3*l.XS, l.YM for i in range(4): s.foundations.append(DieRussische_Foundation(x, y, self, suit=i, max_cards=8)) x += l.XS x, y = l.XM+l.XS/2, l.YM+l.YS for i in range(6): s.rows.append(Thirty_RowStack(x, y, self, max_move=UNLIMITED_MOVES, max_accept=UNLIMITED_ACCEPTS)) x += l.XS x, y = self.width-l.XS, self.height-l.YS s.talon = InitialDealTalonStack(x, y, self) l.defaultAll()
def createGame(self, rows=8, reserves=1): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + (1+max(8,rows))*l.XS, l.YM + (1+max(4, reserves))*l.YS+l.TEXT_HEIGHT) # create stacks x, y = l.XM, l.YM s.talon = self.Talon_Class(x, y, self) for i in range(8): x = x + l.XS s.foundations.append(self.Foundation_Class(x, y, self, suit=i/2)) x, y = l.XM, y + l.YS rx, ry = x + l.XS - l.CW/2, y - l.CH/2 for i in range(reserves): s.reserves.append(self.ReserveStack_Class(x, y+l.TEXT_HEIGHT, self)) y = y + l.YS l.createText(s.talon, "s") if s.reserves: self.setRegion(s.reserves, (-999, ry+l.TEXT_HEIGHT, rx-1, 999999)) else: rx = -999 x, y = l.XM + (8-rows)*l.XS/2, l.YM + l.YS for i in range(rows): x = x + l.XS s.rows.append(self.RowStack_Class(x, y, self)) self.setRegion(s.rows, (rx, ry, 999999, 999999)) # 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+3*l.YS+12*l.YOFFSET) # create stacks x, y = l.XM, l.YM for i in range(4): s.foundations.append( Rittenhouse_Foundation(x, y, self, max_move=0)) x += l.XS x += l.XS for i in range(4): s.foundations.append(Rittenhouse_Foundation(x, y, self, base_rank=KING, dir=-1, max_move=0)) x += l.XS x, y = l.XM, l.YM+l.YS for i in range(9): s.rows.append(UD_RK_RowStack(x, y, self)) x += l.XS s.talon = InitialDealTalonStack(l.XM, self.height-l.YS, self) # default l.defaultAll()
def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = 3*l.XM+8*l.XS, l.YM+2*l.YS+15*l.YOFFSET self.setSize(w, h) # create stacks x, y = 2*l.XM, l.YM+l.YS for i in range(8): s.rows.append(self.RowStack_Class(x, y, self)) x += l.XS y = l.YM for i in range(4): x = l.XM+i*l.XS s.foundations.append(SS_FoundationStack(x, y, self, i, max_move=0)) x += 2*l.XM+4*l.XS s.foundations.append(SS_FoundationStack(x, y, self, i, base_rank=KING, max_move=0, dir=-1)) s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self) # default l.defaultAll()
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): # create layout l, s = Layout(self), self.s # set window # (set size so that at least 7 cards are fully playable) dx = l.XM+l.XS+7*l.XOFFSET w = l.XM+max(5*dx, 9*l.XS+2*l.XM) h = l.YM+6*l.YS self.setSize(w, h) # create stacks x, y = l.XM, l.YM s.talon = TalonStack(x, y, self) l.createText(s.talon, "se") x = max(l.XS+3*l.XM, (self.width-l.XM-8*l.XS)//2) 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 y = l.YM+l.YS for i in range(5): x = l.XM for j in range(5): stack = UD_SS_RowStack(x, y, self) s.rows.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 x += dx y += l.YS # define stack-groups l.defaultStackGroups()
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), self.s # set window self.setSize(l.XM+10.5*l.XS, l.YM+2*l.YS+20*l.YOFFSET) # create stacks x, y = l.XM, l.YM+l.YS//2 for i in (0, 1): stack = ReserveStack(x, y, self, max_cards=4) s.reserves.append(stack) stack.CARD_YOFFSET = l.YOFFSET l.createText(stack, 'n') x += l.XS x, y = l.XM+2.5*l.XS, l.YM for i in range(8): s.foundations.append(SS_FoundationStack(x, y, self, suit=i//2)) x += l.XS x, y = l.XM+2.5*l.XS, l.YM+l.YS for i in range(8): 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) # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = l.XM+(8+2)*l.XS, l.YM+max(3*(l.YS+8*l.YOFFSET), 8*l.YS) self.setSize(w, h) # create stacks y = l.YM for i in range(3): x = l.XM for j in range(8): s.rows.append(UD_SS_RowStack(x, y, self, base_rank=NO_RANK)) x += l.XS y += l.YS+8*l.YOFFSET y = l.YM for j in range(2): for i in range(4): x = l.XM+8*l.XS s.foundations.append(SS_FoundationStack(x, y, self, suit=j*2+i//2, max_move=0)) x += l.XS s.foundations.append( SS_FoundationStack( x, y, self, suit=j*2+i//2, base_rank=KING, max_move=0, dir=-1)) y += l.YS s.talon = InitialDealTalonStack(l.XM, h-l.YS, self) # default l.defaultAll()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+13*l.XS, l.YM+3*l.YS+12*l.YOFFSET) # create stacks y = l.YM for i in range(2): x = l.XM+2*l.XS for j in range(8): s.foundations.append(Spider_SS_Foundation(x, y, self, dir=-2, base_rank=ANY_RANK, min_accept=6, max_cards=6, max_move=0)) x += l.XS s.foundations.append(TheJollyRoger_Foundation(x, y, self, suit=ANY_SUIT, dir=0, min_accept=4, max_accept=4, max_cards=4, max_move=0)) y += l.YS x, y = l.XM, l.YM+2*l.YS for i in range(13): s.rows.append(TheJollyRoger_RowStack(x, y, self, dir=2, max_move=UNLIMITED_MOVES, max_accept=UNLIMITED_ACCEPTS)) x += l.XS s.talon = DealRowTalonStack(l.XM, l.YM, self) l.createText(s.talon, 's') # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window w, h = 2*l.XM+8*l.XS, max(2*(l.YM+l.YS+8*l.YOFFSET), l.YM+5*l.YS) self.setSize(w, h) # create stacks x, y = l.XM, l.YM for i in range(6): s.rows.append(UD_SS_RowStack(x, y, self, base_rank=NO_RANK)) x += l.XS x, y = l.XM, l.YM+l.YS+8*l.YOFFSET for i in range(6): s.rows.append(UD_SS_RowStack(x, y, self, base_rank=NO_RANK)) x += l.XS y = l.YM for i in range(4): x = l.XM+6*l.XS+l.XM s.foundations.append(SS_FoundationStack(x, y, self, i, max_move=0)) x += l.XS s.foundations.append(SS_FoundationStack(x, y, self, i, base_rank=KING, max_move=0, dir=-1)) y += l.YS s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self) # default l.defaultAll()
def createGame(self, **layout): l, s = Layout(self), self.s kwdefault(layout, rows=14, reserves=4, texts=0) self.Layout_Method(l, **layout) self.setSize(l.size[0], l.size[1]) # Create foundations for r in l.s.foundations: s.foundations.append( self.Foundation_Class( r.x, r.y, self, r.suit, mod=12, max_cards=12)) # Create reserve stacks for r in l.s.reserves: s.reserves.append(ReserveStack(r.x, r.y, self, )) # Create row stacks for r in l.s.rows: s.rows.append( self.RowStack_Class( r.x, r.y, self, max_cards=12, suit=ANY_SUIT, base_rank=self.BASE_RANK)) # Create talon s.talon = self.Talon_Class(l.s.talon.x, l.s.talon.y, self) # Define stack groups l.defaultAll()
def createGame(self, rows=8, reserves=1): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM+11*l.XS, l.YM+2*l.YS+12*l.YOFFSET+20) # create stacks x, y = l.XM, l.YM s.talon = self.Talon_Class(x, y, self) l.createText(s.talon, 's') x += l.XS stack = Surprise_ReserveStack(x, y, self, max_cards=3) xoffset = min(l.XOFFSET, l.XS/3) stack.CARD_XOFFSET = xoffset s.reserves.append(stack) x += 2*l.XS for i in range(8): s.foundations.append(SS_FoundationStack(x, y, self, suit=i/2)) x += l.XS x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT for i in range(11): s.rows.append(KingAC_RowStack(x, y, self)) x += l.XS # define stack-groups l.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM+10*l.XS, l.YM+2*l.YS+12*l.YOFFSET) # extra settings self.base_card = None # create stacks x, y = l.XM+3*l.XS, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i, mod=13)) x = x + l.XS tx, ty, ta, tf = l.getTextAttr(s.foundations[-1], "ne") 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(10): s.rows.append(UD_AC_RowStack(x, y, self, mod=13)) x += l.XS x, y = l.XM, l.YM s.talon = InitialDealTalonStack(x, y, self) # default l.defaultAll()
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), self.s # set window # (piles up to 9 cards are fully playable in default window size) dh = max(3*l.YS/2+l.CH, l.YS+(9-1)*l.YOFFSET) self.setSize(10*l.XS+l.XM, l.YM+2*dh) # create stacks for i in range(2): x, y = l.XM, l.YM + i*dh for j in range(4): s.rows.append(RK_RowStack(x, y, self, max_move=1, max_accept=1)) x = x + l.XS y = l.YM + dh - l.CH / 2 self.setRegion(s.rows[:4], (-999, -999, x - l.XM / 2, y)) self.setRegion(s.rows[4:], (-999, y, x - l.XM / 2, 999999)) d = [ (0,0), (1,0.15), (2,0.5), (2.5,1.5), (2,2.5), (1,2.85) ] for i in range(len(d)): d.append( (0 - d[i][0], 3 - d[i][1]) ) x0, y0 = l.XM, l.YM + dh - l.CH for i in range(12): j = (i + 5) % 12 x = int(round(x0 + ( 6.5+d[j][0]) * l.XS)) y = int(round(y0 + (-1.5+d[j][1]) * l.YS)) suit = (1, 2, 0, 3) [i % 4] s.foundations.append(SS_FoundationStack(x, y, self, suit, base_rank=i+1, mod=13, max_move=0)) s.talon = InitialDealTalonStack(self.width-l.XS, self.height-l.YS, self) # define stack-groups self.sg.openstacks = s.foundations + s.rows self.sg.talonstacks = [s.talon] self.sg.dropstacks = s.rows
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 h = l.YS + 7 * l.YOFFSET self.setSize(l.XM + 10 * l.XS, l.YM + l.YS + 2 * h) # create stacks x, y = self.width - l.XS, self.height - l.YS s.talon = InitialDealTalonStack(x, y, self) x, y = l.XM + l.XS, l.YM for i in range(8): s.rows.append( SS_RowStack(x, y, self, dir=1, max_move=1, max_accept=1)) x += l.XS x, y = l.XM + l.XS, l.YM + l.YS + h for i in range(8): s.rows.append( SS_RowStack(x, y, self, dir=-1, max_move=1, max_accept=1)) x += l.XS x, y = l.XM + l.XS, l.YM + h for i in range(8): stack = HeadsAndTails_Reserve(x, y, self) s.reserves.append(stack) l.createText(stack, "n") x += l.XS 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 = l.XM + 9 * 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 # define stack-groups l.defaultStackGroups()
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 = 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): # 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 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, rows=10, playcards=20): l, s = Layout(self), self.s self.setSize(l.XM + max(rows, 8) * l.XS, l.YM + 2 * l.YS + playcards * l.YOFFSET) x, y = l.XM, l.YM stack = OpenStack(x, y, self, max_move=1, max_accept=0) s.reserves.append(stack) l.createText(stack, 'ne') x, y = self.width - 8 * l.XS, l.YM for i in range(8): s.foundations.append(SS_FoundationStack(x, y, self, suit=i // 2)) x += l.XS x, y = self.width - rows * l.XS, l.YM + l.YS for i in range(rows): s.rows.append(Yukon_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): # , rows=9, reserves=8): # create layout l, s = Layout(self), self.s # set size self.setSize(l.XM + 10 * l.XS, l.YM + (5 + len(self.Foundation_Classes)) * 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 y = l.YM for found_class in self.Foundation_Classes: x = l.XM for i in range(8): s.foundations.append( found_class(x, y, self, suit=ANY_SUIT, max_move=0)) x += l.XS y += l.YS x, y = l.XM, l.YM + l.YS * len(self.Foundation_Classes) self.setRegion(s.foundations, (-999, -999, 999999, y - l.XM // 2)) for i in range(8): stack = self.RowStack_Class(x, y, self, max_move=1) stack.CARD_XOFFSET = xoffset stack.CARD_YOFFSET = yoffset s.rows.append(stack) x += l.XS s.talon = self.Talon_Class(l.XM + 9 * l.XS, l.YM, self) l.createText(s.talon, "s") # define stack-groups l.defaultStackGroups()
def createGame(self, playcards=5): # create layout l, s = Layout(self), self.s # set window w = max(2 * l.XS, l.XS + (playcards - 1) * l.XOFFSET) self.setSize(l.XM + 5 * w, l.YM + 4 * l.YS) # create stacks y = l.YM for i in range(5): x = l.XM + i * w s.rows.append(self.RowStack_Class(x, y, self)) for i in range(2): y = y + l.YS for j in (0, 1, 3, 4): x = l.XM + j * w s.rows.append(self.RowStack_Class(x, y, self)) y = y + l.YS for i in range(4): x = l.XM + i * w s.rows.append(self.RowStack_Class(x, y, self)) for r in s.rows: r.CARD_XOFFSET = l.XOFFSET r.CARD_YOFFSET = 0 x, y = l.XM + 2 * w, l.YM + 3 * l.YS // 2 s.foundations.append( BlackHole_Foundation(x, y, self, suit=ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=52)) l.createText(s.foundations[0], "s") x, y = l.XM + 4 * w, self.height - l.YS s.talon = InitialDealTalonStack(x, y, self) # define stack-groups l.defaultStackGroups()
def createGame(self, rows=3, columns=6): layout, s = Layout(self), self.s decks = self.gameinfo.decks maxrows = max(columns, 2 + decks * 4) self.setSize(layout.XM + maxrows * layout.XS, layout.YM + (rows + 1) * layout.YS) x, y = layout.XM, layout.YM s.talon = TalonStack(x, y, self) layout.createText(s.talon, 'ne') x, y = layout.XM + 2 * layout.XS, layout.YM for found in self.Foundation_Classes: if self.SEPARATE_FOUNDATIONS: for i in range(4): s.foundations.append(found(x, y, self, suit=i)) x += layout.XS else: s.foundations.append(found(x, y, self, suit=ANY_SUIT)) if self.SPREAD_FOUNDATION: w1, w2 = 6 * layout.XS + layout.XM, 2 * layout.XS totalcards = self.gameinfo.ncards if w2 + totalcards * layout.XOFFSET > w1: layout.XOFFSET = int((w1 - w2) / totalcards) s.foundations[0].CARD_XOFFSET = layout.XOFFSET y = layout.YM + layout.YS for i in range(rows): x = layout.XM + (maxrows - columns) * layout.XS // 2 for j in range(columns): s.rows.append(Vague_RowStack(x, y, self)) x += layout.XS y += layout.YS layout.defaultStackGroups()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 9 * l.XS, l.YM + 3 * l.YS + 12 * l.YOFFSET) # create stacks x, y = l.XM + l.XS, l.YM for i in range(8): s.foundations.append( MountOlympus_Foundation(x, y, self, suit=i / 2, base_rank=ACE, dir=2, max_move=0, max_cards=7)) x += l.XS x, y = l.XM + l.XS, l.YM + l.YS for i in range(8): s.foundations.append( MountOlympus_Foundation(x, y, self, suit=i / 2, base_rank=1, dir=2, max_move=0, max_cards=6)) x += l.XS x, y = l.XM, l.YM + 2 * l.YS for i in range(9): s.rows.append(self.RowStack_Class(x, y, self, dir=-2)) x += l.XS s.talon = DealRowTalonStack(l.XM, l.YM, self) l.createText(s.talon, 's') # define stack-groups l.defaultStackGroups()
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, **layout): # create layout l, s = Layout(self), self.s kwdefault(layout, rows=8, waste=0, texts=1, playcards=20) l.klondikeLayout(**layout) self.setSize(l.size[0], l.size[1]) # create stacks s.talon = Dumfries_TalonStack(l.s.talon.x, l.s.talon.y, self) for r in l.s.foundations: s.foundations.append( SS_FoundationStack(r.x, r.y, self, suit=r.suit)) for r in l.s.rows: s.rows.append( Dumfries_RowStack(r.x, r.y, self, max_move=UNLIMITED_MOVES, max_accept=UNLIMITED_ACCEPTS)) # default l.defaultAll() self.sg.dropstacks.append(s.talon)
def createGame(self, rows=8, reserves=6, playcards=12): # create layout l, s = Layout(self), self.s # set window decks = self.gameinfo.decks foundations = decks * 4 max_rows = max(foundations, rows) w, h = l.XM + (max_rows + 1) * l.XS, l.YM + 3 * l.YS + playcards * l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM + l.XS + (max_rows - foundations) * l.XS // 2, l.YM for fclass in self.Foundation_Classes: for i in range(4): s.foundations.append(fclass(x, y, self, suit=i)) x += l.XS x, y = l.XM + l.XS + (max_rows - rows) * l.XS // 2, l.YM + l.YS for i in range(rows): s.rows.append( self.RowStack_Class(x, y, self, max_move=1, max_accept=1)) x += l.XS self.setRegion(s.rows, (-999, y - l.CH // 2, 999999, h - l.YS - l.CH // 2)) d = (w - reserves * l.XS) // reserves x, y = l.XM, h - l.YS for i in range(reserves): stack = ReserveStack(x, y, self) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 2, 0 s.reserves.append(stack) x += l.XS + d s.talon = self.Talon_Class(l.XM, l.YM, self) l.createText(s.talon, "s") # define stack-groups l.defaultStackGroups()
def createGame(self): # create layout layout, s = Layout(self), self.s # set window h = layout.YM + layout.YS + 4 * layout.YOFFSET self.setSize(layout.XM + 7 * layout.XS, 3 * layout.YM + 2 * h + layout.YS) # create stacks x, y = layout.XM, layout.YM for i in range(7): s.rows.append(self.RowStack_Class(x, y, self)) x += layout.XS x, y = layout.XM, layout.YM + h for i in range(6): s.rows.append(self.RowStack_Class(x, y, self)) x += layout.XS for r in s.rows: r.CARD_XOFFSET, r.CARD_YOFFSET = 0, layout.YOFFSET x, y = layout.XM, self.height - layout.YS stack = BlackHole_Foundation(x, y, self, ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=52, base_rank=ANY_RANK) s.foundations.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = (self.width - layout.XS) // 51, 0 layout.createText(stack, 'n') x = self.width - layout.XS s.talon = InitialDealTalonStack(x, y, self) # define stack-groups layout.defaultStackGroups()
def createGame(self): l, s = Layout(self), self.s font = self.app.getFont("canvas_default") # Set window size self.setSize(l.XM * 3 + l.XS * 9, l.YM + l.YS * 6) # Create row stacks x = l.XM y = l.YM for i in range(8): s.rows.append( RK_RowStack(x, y, self, base_rank=11, max_move=12, max_cards=99)) x = x + l.XS # Create reserve stacks x = self.width - l.XS y = l.YM for i in range(6): s.reserves.append(ReserveStack(x, y, self)) y = y + l.YS y = y - l.YS for i in range(4): x = x - l.XS s.reserves.append(ReserveStack(x, y, self)) self.setRegion(s.rows, (0, 0, l.XM + l.XS * 8, l.YS * 5)) # Create talon s.talon = DealRowTalonStack(l.XM, self.height - l.YS, self) l.createText(s.talon, "n") # Define stack groups 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, round_text=True): decks = self.gameinfo.decks # create layout l, s = Layout(self, card_x_space=4), self.s # set window w, h = l.XM + self.RSTEP * l.XS, l.YM + (4 * decks) * l.YS if round_text: h += l.YS self.setSize(w, h) # create stacks for k in range(decks): for i in range(4): x, y = l.XM, l.YM + (i + k * 4) * l.YS for j in range(self.RSTEP): s.rows.append( self.RowStack_Class(x, y, self, max_accept=1, max_cards=1)) x += l.XS if round_text: x, y = l.XM + (self.RSTEP - 1) * l.XS // 2, self.height - l.YS s.talon = self.Talon_Class(x, y, self) l.createRoundText(s.talon, 'se') else: # Talon is invisible x, y = self.getInvisibleCoords() s.talon = self.Talon_Class(x, y, self) if self.RBASE: # create an invisible stack to hold the four Aces s.internals.append(InvisibleStack(self)) # define stack-groups 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 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): 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, 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(l.XM + 7*l.XS, l.YM + 5*l.YS) # create stacks for i in (0, 2.5): for j in range(6): x, y = l.XM + j*l.XS, l.YM + i*l.YS s.rows.append(self.RowStack_Class(x, y, self, max_move=1, max_accept=1, dir=0, base_rank=NO_RANK)) x, y = l.XM + 6*l.XS, l.YM s.foundations.append(self.Foundation_Class(x, y, self, suit=ANY_SUIT, max_move=0, max_cards=52, base_rank=ANY_RANK)) l.createText(s.foundations[0], "s") x, y = self.width - l.XS, self.height - l.YS s.talon = InitialDealTalonStack(x, y, self) # define stack-groups l.defaultStackGroups()
def createGame(self, rows=8, reserves=4, playcards=6): layout, s = Layout(self), self.s self.setSize( layout.XM+rows*layout.XS, layout.YM+3*layout.YS+playcards*layout.YOFFSET) dx = (self.width-layout.XM-(reserves+1)*layout.XS)//3 x, y = layout.XM+dx, layout.YM for i in range(reserves): s.reserves.append(ReserveStack(x, y, self)) x += layout.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)) layout.createText(s.foundations[0], 'ne') x, y = layout.XM, layout.YM+layout.YS for i in range(rows): s.rows.append(BasicRowStack(x, y, self)) x += layout.XS s.talon = InitialDealTalonStack(layout.XM, self.height-layout.YS, self) layout.defaultAll()
def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 9 * l.XS, l.YM + 2 * l.YS + 12 * l.YOFFSET) # create stacks x, y, = l.XM + l.XS, l.YM for i in range(8): s.foundations.append( DieRussische_Foundation(x, y, self, suit=i % 4, max_cards=8)) x += l.XS x, y, = l.XM + l.XS, l.YM + l.YS for i in range(8): s.rows.append(AC_RowStack(x, y, self, max_move=1, max_accept=1)) x += l.XS s.talon = RedealTalonStack(l.XM, l.YM + l.YS / 2, self, max_rounds=3) l.createRoundText(s.talon, 'nn') # define stack-groups l.defaultStackGroups()
def createGame(self, rows=8): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + rows*l.XS, l.YM + 4*l.YS) # create stacks x, y, = l.XM, l.YM s.talon = OpenTalonStack(x, y, self) l.createText(s.talon, "se") for i in range(4): x, y = l.XM + (i+2)*l.XS, l.YM s.foundations.append( Strategy_Foundation(x, y, self, suit=i, max_move=0)) x, y = l.XM, l.YM+l.YS for i in range(rows): s.rows.append(Strategy_RowStack(x, y, self, max_move=1, max_accept=1)) x += l.XS # define stack-groups l.defaultStackGroups() self.sg.dropstacks.append(s.talon)
def createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 9 * l.XS, max(l.YM + l.YS + 20 * l.YOFFSET, l.YM + 6 * l.YS)) x, y, = l.XM + 1.5 * l.XS, l.YM for i in range(6): s.rows.append(LadiesBattle_RowStack(x, y, self, max_move=1, mod=13)) x = x + l.XS x, y = l.XM, l.YM + l.YS / 2 for i in range(4): s.reserves.append(OpenStack(x, y, self, max_accept=0)) y += l.YS x, y = self.width - l.XS, l.YM + l.YS / 2 for i in range(4): s.foundations.append( SS_FoundationStack(x, y, self, suit=i, base_rank=QUEEN, mod=13)) y += l.YS x, y = self.width - l.XS, self.height - l.YS s.talon = DealRowTalonStack(x, y, self) l.createText(s.talon, "sw") l.defaultStackGroups()
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