def createGame(self): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + 8*l.XS, l.YM + 2*l.YS+16*l.YOFFSET) # create stacks x, y, = l.XM, l.YM for i in range(8): if self.Foundation_Class is RK_FoundationStack: suit = ANY_SUIT else: suit = int(i//2) s.foundations.append(self.Foundation_Class(x, y, self, suit=suit, max_move=0)) x += l.XS x, y = l.XM, l.YM+l.YS stack = OpenStack(x, y, self, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET s.reserves.append(stack) x += l.XS s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, "s") x += l.XS s.waste = WasteStack(x, y, self, max_cards=1) x += l.XS for i in range(5): stack = Numerica_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS) # stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET s.rows.append(stack) x = x + l.XS # define stack-groups l.defaultStackGroups()
def _position(self, card): OpenStack._position(self, card) # if TOOLKIT == 'tk': rows = [s for s in self.game.s.rows[:self.id] if s.cards] if rows: self.group.tkraise(rows[-1].group) return rows = [s for s in self.game.s.rows[self.id+1:] if s.cards] if rows: self.group.lower(rows[0].group) return elif TOOLKIT == 'kivy': rows = [s for s in self.game.s.rows[:self.id] if s.cards] if rows: # self.group.tkraise(rows[-1].group) return rows = [s for s in self.game.s.rows[self.id+1:] if s.cards] if rows: # self.group.lower(rows[0].group) return elif TOOLKIT == 'gtk': # FIXME (this is very slow) for s in self.game.s.rows[self.id+1:]: s.group.tkraise()
def createGame(self, rows=8, reserves=8, playcards=7): # create layout l, s = Layout(self), self.s # set window max_rows = max(rows, reserves) w, h = l.XM + max_rows*l.XS, l.YM + 2*l.YS + (12+playcards)*l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM + (max_rows-rows)*l.XS//2, l.YM for i in range(rows): stack = self.RowStack_Class(x, y, self, base_rank=ANY_RANK) stack.getBottomImage = stack._getReserveBottomImage s.rows.append(stack) x += l.XS x, y = l.XM + (max_rows-reserves)*l.XS//2, l.YM+l.YS+12*l.YOFFSET for i in range(reserves): stack = OpenStack(x, y, self, max_accept=0) s.reserves.append(stack) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET x += l.XS s.talon = InitialDealTalonStack(l.XM, l.YM, self) # default l.defaultAll()
def createGame(self): # create layout lay, s = Layout(self), self.s # set window w = max(8*lay.XS, 6*lay.XS+8*lay.XOFFSET) h = lay.YM+3*lay.YS+12*lay.YOFFSET self.setSize(w+lay.XM, h) # create stacks y = lay.YM for x in (lay.XM, lay.XM+w-lay.XS-4*lay.XOFFSET): stack = OpenStack(x, y, self, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = lay.XOFFSET, 0 s.reserves.append(stack) x, y = lay.XM+(w-4*lay.XS)//2, lay.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) x += lay.XS x, y = lay.XM+(w-8*lay.XS)//2, lay.YM+lay.YS for i in range(8): s.rows.append(AC_RowStack(x, y, self)) x += lay.XS s.talon = WasteTalonStack(lay.XM, h-lay.YS, self, max_rounds=1) lay.createText(s.talon, "n") s.waste = WasteStack(lay.XM+lay.XS, h-lay.YS, self) lay.createText(s.waste, "n") # define stack-groups lay.defaultStackGroups()
def createGame(self): lay, s = Layout(self), self.s self.setSize(lay.XM+8*lay.XS, lay.YM+2*lay.YS+12*lay.YOFFSET) x, y = lay.XM, lay.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) s.foundations.append(SS_FoundationStack(x+4*lay.XS, y, self, suit=i, base_rank=KING, dir=-1)) x += lay.XS x, y = lay.XM, lay.YM+lay.YS s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3) lay.createText(s.talon, 'ne') y += lay.YS s.waste = WasteStack(x, y, self) lay.createText(s.waste, 'ne') x, y = lay.XM+2*lay.XS, lay.YM+lay.YS for i in range(4): s.rows.append(AC_RowStack(x, y, self, base_rank=6)) x += lay.XS x += lay.XS stack = OpenStack(x, y, self) s.reserves.append(stack) stack.CARD_YOFFSET = lay.YOFFSET lay.defaultStackGroups()
def __init__(self, x, y, game, yoffset=-1, **cap): kwdefault( cap, max_move=UNLIMITED_MOVES, max_accept=UNLIMITED_ACCEPTS, dir=-1) OpenStack.__init__(self, x, y, game, **cap) if yoffset < 0: yoffset = game.app.images.CARD_YOFFSET self.CARD_YOFFSET = yoffset
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): OpenStack.moveMove(self, ncards, to_stack, frames, shadow) if self.game.base_rank is None and to_stack in self.game.s.foundations: old_state = self.game.enterState(self.game.S_FILL) self.game.saveStateMove(2 | 16) # for undo self.game.base_rank = to_stack.cards[-1].rank self.game.saveStateMove(1 | 16) # for redo self.game.leaveState(old_state)
def __init__(self, x, y, game): OpenStack.__init__(self, x, y, game) self.CARD_YOFFSET = self.game.app.images.CARD_YOFFSET # use a sine wave for the x offsets self.CARD_XOFFSET = [] j = 1 for i in range(20): self.CARD_XOFFSET.append(int(math.sin(j) * 20)) j = j + .9
def __init__(self, x, y, game, xoffset, yoffset): OpenStack.__init__(self, x, y, game) self.CARD_YOFFSET = int(self.game.app.images.CARD_YOFFSET * yoffset) # use a sine wave for the x offsets self.CARD_XOFFSET = [] j = 1 for i in range(30): self.CARD_XOFFSET.append(int(math.cos(j) * xoffset)) j = j + .9
def __init__(self, x, y, game, yoffset): OpenStack.__init__(self, x, y, game) self.CARD_YOFFSET = int(self.game.app.images.CARD_YOFFSET * yoffset) # use a sine wave for the x offsets # compensate for card width offset = self.game.app.images.CARDW / 1.7 self.CARD_XOFFSET = [] j = 1 for i in range(20): self.CARD_XOFFSET.append(int(math.sin(j) * offset)) j = j + .9
def _position(self, card): # AbstractFoundationStack._position(self, card) OpenStack._position(self, card) fnds = self.game.s.foundations cols = (3, 2, 1, 0) for i in cols: for j in range(9): n = i*9+j if fnds[n].cards: fnds[n].group.tkraise() return
def createGame(self, rows=1, reserves=8, playcards=3): # create layout l, s = Layout(self), self.s # set window w, h = l.XM+8*l.XS, l.YM+3.5*l.YS+playcards*l.YOFFSET h += l.TEXT_HEIGHT self.setSize(w, h) # create stacks x, y, = l.XM, l.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i, max_move=0)) x += l.XS for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i, max_move=0, base_rank=KING, dir=-1)) x += l.XS x, y, = l.XM+(8-reserves)*l.XS//2, y+l.YS for i in range(reserves): stack = OpenStack(x, y, self, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET s.reserves.append(stack) x += l.XS x, y = l.XM+(8-1-rows)*l.XS//2, self.height-l.YS s.talon = Alhambra_Talon(x, y, self, max_rounds=3) if rows == 1: l.createText(s.talon, 'sw') else: l.createText(s.talon, 'n') anchor = 'nn' if rows > 1: anchor = 'nnn' l.createRoundText(s.talon, anchor) x += l.XS for i in range(rows): stack = self.RowStack_Class(x, y, self, mod=13, max_accept=1) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, 0 s.rows.append(stack) x += l.XS if rows == 1: l.createText(stack, 'se') else: l.createText(stack, 'n') # define stack-groups (non default) l.defaultStackGroups()
def canFlipCard(self): if not OpenStack.canFlipCard(self): return False for r in self.game.s.reserves: if len(r.cards) > 2: return False return True
def acceptsCards(self, from_stack, cards): if not OpenStack.acceptsCards(self, from_stack, cards): return False # check the rank if self.cards[-1].rank != cards[0].rank: return False # now look if the stacks are neighbours return self.game.isNeighbour(from_stack, self)
def __init__(self, x, y, game, sine=0): OpenStack.__init__(self, x, y, game) self.CARD_YOFFSET = self.game.app.images.CARD_YOFFSET CW = self.game.app.images.CARDW if sine: # use a sine wave for the x offsets self.CARD_XOFFSET = [] n = 9 dx = 0.4 * CW * (2*math.pi/n) last_x = 0 for i in range(n): x = int(round(dx * math.sin(i + 1))) # print x, x - last_x self.CARD_XOFFSET.append(x - last_x) last_x = x else: self.CARD_XOFFSET = (-0.45*CW, 0.35*CW, 0.55*CW, -0.45*CW)
def clickHandler(self, event): result = OpenStack.doubleclickHandler(self, event) if result == 1 and not self.game.score_counted: self.game.sequence += 1 self.game.computeHandScore() self.game.updateText() elif self.game.score_counted: self.game.score_counted = False return result
def acceptsCards(self, from_stack, cards): if not OpenStack.acceptsCards(self, from_stack, cards): return False # check the rank if self.cards[-1].rank + cards[0].rank + 2 == 10: return True if self.cards[-1].rank > 9 and self.cards[-1].rank == cards[0].rank: return True return False
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 # Set window size decks = self.gameinfo.decks self.setSize(2 * l.XM + (2 + 5 * decks) * l.XS, 3 * l.YM + 5 * l.YS) yoffset = min(l.YOFFSET, max(10, l.YOFFSET / 2)) # Create talon x = l.XM y = l.YM s.talon = WasteTalonStack(x, y, self, num_deal=1, max_rounds=self.MAX_ROUNDS) l.createText(s.talon, "s") x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "s") # Create foundations x = x + l.XM + l.XS for j in range(4): for i in range(decks): s.foundations.append( SS_FoundationStack(x, y, self, j, max_cards=14)) x = x + l.XS for i in range(decks): s.foundations.append( SS_FoundationStack(x, y, self, 4, max_cards=22)) x = x + l.XS # Create reserve x = l.XM y = l.YM + l.YS + l.TEXT_HEIGHT s.reserves.append(OpenStack(x, y, self)) s.reserves[0].CARD_YOFFSET = (l.YOFFSET, yoffset)[decks == 2] # Create rows x = x + l.XM + l.XS for i in range(decks): s.rows.append(TrumpOnly_RowStack(x, y, self, yoffset=yoffset)) x = x + l.XS for i in range(4 * decks + 1): s.rows.append(Tarock_AC_RowStack(x, y, self)) x = x + l.XS self.setRegion(s.rows, (-999, y - l.YS, 999999, 999999)) # Define stack groups l.defaultStackGroups()
def createGame(self, reserves=3, rows=5): # create layout l, s = Layout(self), self.s # set window n = 52 // reserves + 1 w, h = l.XM + (reserves + rows + 1) * l.XS, l.YM + 2 * l.YS + n * l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM + (reserves + rows + 1 - 4) * l.XS // 2, l.YM for i in range(4): if self.Foundation_Class is RK_FoundationStack: suit = ANY_SUIT else: suit = i s.foundations.append( self.Foundation_Class(x, y, self, suit=suit, max_move=0)) x += l.XS x, y = l.XM, l.YM + l.YS for i in range(reserves): stack = OpenStack(x, y, self, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET s.reserves.append(stack) x += l.XS x += l.XS for i in range(rows): s.rows.append( Gloaming_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS)) x += l.XS s.talon = InitialDealTalonStack(w - l.XS, h - l.YS, self) # default l.defaultAll()
def canFlipCard(self): if not OpenStack.canFlipCard(self): return False for s in self.game.s.rows: if not s.cards: break else: return False i = list(self.game.s.reserves).index(self) if i == 0: return True if self.game.s.reserves[i - 1].cards: return False return True
def canFlipCard(self): if not OpenStack.canFlipCard(self): return False for s in self.game.s.rows: if not s.cards: break else: return False i = list(self.game.s.reserves).index(self) if i == 0: return True if self.game.s.reserves[i-1].cards: return False return True
def createGame(self, reserves=3, rows=5): # create layout l, s = Layout(self), self.s # set window n = 52//reserves+1 w, h = l.XM + (reserves+rows+1)*l.XS, l.YM + 2*l.YS+n*l.YOFFSET self.setSize(w, h) # create stacks x, y = l.XM+(reserves+rows+1-4)*l.XS//2, l.YM for i in range(4): if self.Foundation_Class is RK_FoundationStack: suit = ANY_SUIT else: suit = i s.foundations.append(self.Foundation_Class(x, y, self, suit=suit, max_move=0)) x += l.XS x, y = l.XM, l.YM+l.YS for i in range(reserves): stack = OpenStack(x, y, self, max_accept=0) stack.CARD_XOFFSET, stack.CARD_YOFFSET = 0, l.YOFFSET s.reserves.append(stack) x += l.XS x += l.XS for i in range(rows): s.rows.append( Gloaming_RowStack(x, y, self, max_accept=UNLIMITED_ACCEPTS)) x += l.XS s.talon = InitialDealTalonStack(w-l.XS, h-l.YS, self) # default l.defaultAll()
def acceptsCards(self, from_stack, cards): if not OpenStack.acceptsCards(self, from_stack, cards): return False if not self.cards: return True if cards[0].suit != self.cards[0].suit: return False if len(self.cards) == 1: card_dir = cards[0].rank - self.cards[-1].rank return card_dir == 1 or card_dir == -1 else: stack_dir = (self.cards[1].rank - self.cards[0].rank) % \ self.cap.mod return (self.cards[-1].rank + stack_dir) % \ self.cap.mod == cards[0].rank
def createGame(self): lay, s = Layout(self), self.s self.setSize(lay.XM + 8 * lay.XS, lay.YM + 2 * lay.YS + 12 * lay.YOFFSET) x, y = lay.XM, lay.YM for i in range(4): s.foundations.append(SS_FoundationStack(x, y, self, suit=i)) s.foundations.append( SS_FoundationStack(x + 4 * lay.XS, y, self, suit=i, base_rank=KING, dir=-1)) x += lay.XS x, y = lay.XM, lay.YM + lay.YS s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3) lay.createText(s.talon, 'ne') y += lay.YS s.waste = WasteStack(x, y, self) lay.createText(s.waste, 'ne') x, y = lay.XM + 2 * lay.XS, lay.YM + lay.YS for i in range(4): s.rows.append(AC_RowStack(x, y, self, base_rank=6)) x += lay.XS x += lay.XS stack = OpenStack(x, y, self) s.reserves.append(stack) stack.CARD_YOFFSET = lay.YOFFSET lay.defaultStackGroups()
def createGame(self): 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 createGame(self): l, s = Layout(self), self.s self.setSize(l.XM + 8 * l.XS, l.YM + 5 * l.YS) x0, y0 = l.XM + 2 * l.XS, l.YM # foundations (corners) suit = 0 for i, j in ((0, 0), (5, 0), (0, 4), (5, 4)): x, y = x0 + i * l.XS, y0 + j * l.YS s.foundations.append( Frames_Foundation(x, y, self, suit=suit, dir=0, max_cards=26)) suit += 1 # rows (frame) for i in (1, 2, 3, 4): for j in (0, 4): x, y = x0 + i * l.XS, y0 + j * l.YS stack = Frames_RowStack(x, y, self) s.rows.append(stack) stack.cap.addattr(column=i) stack.CARD_YOFFSET = 0 for i in (0, 5): for j in (1, 2, 3): x, y = x0 + i * l.XS, y0 + j * l.YS stack = Frames_RowStack(x, y, self) s.rows.append(stack) stack.cap.addattr(row=j) stack.CARD_YOFFSET = 0 # reserves (picture) for j in (1, 2, 3): for i in (1, 2, 3, 4): x, y = x0 + i * l.XS, y0 + j * l.YS stack = OpenStack(x, y, self) s.reserves.append(stack) stack.cap.addattr(column=i) stack.cap.addattr(row=j) # talon & waste x, y, = l.XM, l.YM s.talon = WasteTalonStack(x, y, self, max_rounds=1) l.createText(s.talon, 'ne') y += l.YS s.waste = WasteStack(x, y, self) l.createText(s.waste, 'ne') l.defaultStackGroups()
def playFlipMove(self, sound=True, animation=False): rows = int(math.sqrt(self.game.gameinfo.ncards)) playSpace = self.id if playSpace % rows != rows - 1: self.game.s.rows[playSpace + 1].flipMove() if playSpace % rows != 0: self.game.s.rows[playSpace - 1].flipMove() if playSpace + rows < rows**2: self.game.s.rows[playSpace + rows].flipMove() if playSpace - rows >= 0: self.game.s.rows[playSpace - rows].flipMove() return OpenStack.playFlipMove(self, sound, animation)
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 y = l.YM for i in range(2): x = l.XM + 3 * l.XS for j in range(4): s.foundations.append( TwilightZone_Foundation(x, y, self, suit=j)) x += l.XS y += l.YS x, y = l.XM + 3 * l.XS, l.YM + 2 * l.YS for i in range(4): stack = TwilightZone_RowStack(x, y, self, max_move=1) stack.CARD_YOFFSET = 0 s.rows.append(stack) x += l.XS x, y = l.XM + 3 * l.XS, l.YM + 4 * l.YS for i in range(4): s.reserves.append(OpenStack(x, y, self)) x += l.XS x, y = l.XM, l.YM + l.YS / 2 s.talon = TwilightZone_Talon(x, y, self, max_move=1, max_rounds=2) l.createText(s.talon, 's') l.createRoundText(s.talon, 'nn') x += l.XS s.waste = TwilightZone_Waste(x, y, self, max_accept=1) l.createText(s.waste, 's') # define stack-groups l.defaultStackGroups() self.sg.dropstacks.append(s.talon) self.sg.openstacks.append(s.waste)
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): # create layout l, s = Layout(self), self.s s.addattr(xwastes=[]) # register extra stack variable # set window w, h = l.XM + 11 * l.XS, l.YM + 6 * l.YS self.setSize(w, h) # create stacks x, y, = l.XM, l.YM s.talon = Interment_Talon(x, y, self) l.createText(s.talon, 'ne') x += 1.5 * 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 for i in range(3): stack = Interment_Waste(x, y, self, max_cards=UNLIMITED_CARDS) l.createText(stack, 'ne') s.xwastes.append(stack) y += l.YS x, y = l.XM + 1.5 * l.XS, l.YM + l.YS for i in range(8): s.rows.append(SS_RowStack(x, y, self, max_move=1)) x += l.XS x, y = self.width - l.XS, l.YM stack = Interment_Reserve(x, y, self) s.reserves.append(stack) l.createText(stack, 'nw') y += l.YS for i in range(5): s.reserves.append(OpenStack(x, y, self)) y += l.YS # define stack-groups l.defaultStackGroups() self.sg.dropstacks += s.xwastes self.sg.openstacks += s.xwastes self.sg.dropstacks.append(s.talon)
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): 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 __init__(self, x, y, game, **cap): kwdefault(cap, max_cards=1, max_accept=1, base_rank=ANY_RANK) OpenStack.__init__(self, x, y, game, **cap)
def clickHandler(self, event): if self.cards and not self.cards[-1].face_up: return self.game.dealCards(sound=True) return OpenStack.clickHandler(self, event)
def clickHandler(self, event): return OpenStack.clickHandler(self, event)
def clickHandler(self, event): if self._dropKingClickHandler(event): return 1 return OpenStack.clickHandler(self, event)
def __init__(self, x, y, game): OpenStack.__init__(self, x, y, game, max_accept=1, max_cards=2) self.CARD_YOFFSET = 1 self.blockmap = []
def clickHandler(self, event): if self.cards: return OpenStack.clickHandler(self, event) else: return TalonStack.clickHandler(self, event)
def createGame(self, max_rounds=1, num_deal=1): # create layout l, s = Layout(self), self.s # set window self.setSize(l.XM + (8.5 * l.XS), l.YM + ((2 + len(self.FOUNDATION_SETS)) * l.YS)) # create stacks x, y = 2 * l.XM, l.YM w1, w2 = (10 * (l.XS + l.XM)) / self.NUM_RESERVES, 2 * l.XS if w2 + 13 * l.XOFFSET > w1: l.XOFFSET = int((w1 - w2) / 13) for i in range(self.NUM_RESERVES): stack = OpenStack(x, y, self) stack.CARD_XOFFSET = l.XOFFSET l.createText(stack, "sw") s.reserves.append(stack) x += (9 / self.NUM_RESERVES) * l.XS x, y = l.XM, y + l.YS font = self.app.getFont("canvas_default") for i in self.FOUNDATION_SETS: for j in range(4): stack = AcesAndKings_FoundationStack(x, y, self, suit=j, base_rank=i[0], dir=1, max_cards=(13 - i[0])) if self.preview <= 1: stack.texts.misc = MfxCanvasText(self.canvas, x + l.CW // 2, y + l.CH // 2, anchor="center", font=font) stack.texts.misc.config(text=(RANKS[i[0]][0])) s.foundations.append(stack) x = x + l.XS x = x + (l.XS / 2) for j in range(4): stack = AcesAndKings_FoundationStack(x, y, self, suit=j, base_rank=i[1], dir=-1, max_cards=(i[1] + 1)) if self.preview <= 1: stack.texts.misc = MfxCanvasText(self.canvas, x + l.CW // 2, y + l.CH // 2, anchor="center", font=font) stack.texts.misc.config(text=(RANKS[i[1]][0])) s.foundations.append(stack) x = x + l.XS x, y = l.XM, y + l.YS x += (2.5 * l.XM) s.talon = WasteTalonStack( x, y, self, max_rounds=max_rounds, num_deal=num_deal) l.createText(s.talon, "sw") x = x + l.XS s.waste = WasteStack(x, y, self) l.createText(s.waste, "se", text_format="%D") x = ((8.5 - self.NUM_TABLEAU) * l.XS) + l.XM for i in range(self.NUM_TABLEAU): s.rows.append(AcesAndKings_RowStack(x, y, self, max_accept=1)) x = x + l.XS # define stack-groups l.defaultStackGroups()
def copyModel(self, clone): OpenStack.copyModel(self, clone) clone.blockmap = self.blockmap
def canFlipCard(self): if not OpenStack.canFlipCard(self): return False i = list(self.game.s.reserves).index(self) return len(self.game.s.foundations[i].cards) == 13
def acceptsCards(self, from_stack, cards): if not OpenStack.acceptsCards(self, from_stack, cards): return 0 return self.game.cardsMatch(self.cards[0], cards[-1])
def __init__(self, x, y, game, suit=ANY_SUIT, **cap): kwdefault(cap, max_move=0, max_accept=0, max_cards=game.NCARDS) OpenStack.__init__(self, x, y, game, **cap)
def __init__(self, x, y, game, base_rank, yoffset, **cap): kwdefault(cap, dir=3, max_move=99, max_cards=4, max_accept=1, base_rank=base_rank) OpenStack.__init__(self, x, y, game, **cap) self.CARD_YOFFSET = yoffset
def __init__(self, x, y, game, yoffset, **cap): kwdefault(cap, max_move=UNLIMITED_MOVES, max_cards=UNLIMITED_CARDS, max_accept=UNLIMITED_ACCEPTS, base_rank=0, dir=-1) OpenStack.__init__(self, x, y, game, **cap) self.CARD_YOFFSET = yoffset
def __init__(self, x, y, game): OpenStack.__init__(self, x, y, game, max_move=0, max_accept=1) self.CARD_YOFFSET = 1
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): if to_stack in self.game.s.rows and not to_stack.cards: return OpenStack.moveMove(self, ncards, to_stack, frames, shadow) return Giza_Reserve.moveMove(self, ncards, to_stack, frames, shadow)
def acceptsCards(self, from_stack, cards): if not OpenStack.acceptsCards(self, from_stack, cards): return False return self.cards[-1].rank + cards[0].rank == 12
def acceptsCards(self, from_stack, cards): if not OpenStack.acceptsCards(self, from_stack, cards): return 0 if not self.cards: return from_stack in self.game.s.foundations and cards[0].suit == 4 return from_stack in self.game.s.rows