예제 #1
0
    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()
예제 #2
0
파일: braid.py 프로젝트: shlomif/PySolFC
    def createGame(self):
        # create layout
        l, s = Layout(self), self.s

        # set window
        self.setSize(l.XM+6*l.XS, l.YM+6*l.YS+l.TEXT_HEIGHT)

        # register extra stack variables
        s.addattr(wastes=[])

        # foundations
        suit = 0
        x0, y0 = l.XM+1.5*l.XS, l.YM+1.5*l.YS+l.TEXT_HEIGHT
        for xx, yy in ((3, 0),
                       (0, 3),
                       (3, 3),
                       (0, 0)):
            x, y = x0+xx*l.XS, y0+yy*l.YS
            s.foundations.append(SS_FoundationStack(x, y, self, suit=suit,
                                 base_rank=KING, mod=13, max_cards=26,
                                 dir=-1, max_move=0))
            suit += 1

        # rows
        x0, y0 = l.XM+l.XS, l.YM+l.YS+l.TEXT_HEIGHT
        for xx, yy in ((0, 2),
                       (2, 0),
                       (4, 2),
                       (2, 4)):
            x, y = x0+xx*l.XS, y0+yy*l.YS
            stack = SS_RowStack(x, y, self, dir=1, mod=13, max_move=1)
            stack.getBottomImage = stack._getReserveBottomImage
            stack.CARD_YOFFSET = 0
            s.rows.append(stack)

        # left stack
        x, y = l.XM, l.YM+l.YS+l.TEXT_HEIGHT
        stack = SS_RowStack(
            x, y, self, base_rank=ACE, dir=1, mod=13, max_move=1)
        stack.getBottomImage = stack._getReserveBottomImage
        stack.CARD_YOFFSET = 0
        s.rows.append(stack)

        # reserves
        x0, y0 = l.XM+2*l.XS, l.YM+2*l.YS+l.TEXT_HEIGHT
        for xx, yy, anchor in ((0, 1, 'e'),
                               (1, 0, 's'),
                               (2, 1, 'w'),
                               (1, 2, 'n')):
            x, y = x0+xx*l.XS, y0+yy*l.YS
            stack = OpenStack(x, y, self)
            l.createText(stack, anchor)
            s.reserves.append(stack)

        # wastes
        x, y = l.XM+l.XS, l.YM
        for i in range(5):
            stack = WasteStack(x, y, self)
            l.createText(stack, 's', text_format='%D')
            s.wastes.append(stack)
            x += l.XS

        # talon
        x, y = l.XM, l.YM
        s.talon = Well_TalonStack(x, y, self, max_rounds=5)
        l.createText(s.talon, "s")

        # define stack-groups
        self.sg.talonstacks = [s.talon] + s.wastes
        self.sg.openstacks = s.foundations + s.rows
        self.sg.dropstacks = s.rows + s.wastes + s.reserves
예제 #3
0
파일: braid.py 프로젝트: joeraz/PySolFC
    def createGame(self):
        # create layout
        l, s = Layout(self), self.s

        # set window
        self.setSize(l.XM + 6 * l.XS, l.YM + 6 * l.YS + l.TEXT_HEIGHT)

        # register extra stack variables
        s.addattr(wastes=[])

        # foundations
        suit = 0
        x0, y0 = l.XM + 1.5 * l.XS, l.YM + 1.5 * l.YS + l.TEXT_HEIGHT
        for xx, yy in ((3, 0), (0, 3), (3, 3), (0, 0)):
            x, y = x0 + xx * l.XS, y0 + yy * l.YS
            s.foundations.append(
                SS_FoundationStack(x,
                                   y,
                                   self,
                                   suit=suit,
                                   base_rank=KING,
                                   mod=13,
                                   max_cards=26,
                                   dir=-1,
                                   max_move=0))
            suit += 1

        # rows
        x0, y0 = l.XM + l.XS, l.YM + l.YS + l.TEXT_HEIGHT
        for xx, yy in ((0, 2), (2, 0), (4, 2), (2, 4)):
            x, y = x0 + xx * l.XS, y0 + yy * l.YS
            stack = SS_RowStack(x, y, self, dir=1, mod=13, max_move=1)
            stack.getBottomImage = stack._getReserveBottomImage
            stack.CARD_YOFFSET = 0
            s.rows.append(stack)

        # left stack
        x, y = l.XM, l.YM + l.YS + l.TEXT_HEIGHT
        stack = SS_RowStack(x,
                            y,
                            self,
                            base_rank=ACE,
                            dir=1,
                            mod=13,
                            max_move=1)
        stack.getBottomImage = stack._getReserveBottomImage
        stack.CARD_YOFFSET = 0
        s.rows.append(stack)

        # reserves
        x0, y0 = l.XM + 2 * l.XS, l.YM + 2 * l.YS + l.TEXT_HEIGHT
        for xx, yy, anchor in ((0, 1, 'e'), (1, 0, 's'), (2, 1, 'w'), (1, 2,
                                                                       'n')):
            x, y = x0 + xx * l.XS, y0 + yy * l.YS
            stack = OpenStack(x, y, self)
            l.createText(stack, anchor)
            s.reserves.append(stack)

        # wastes
        x, y = l.XM + l.XS, l.YM
        for i in range(5):
            stack = WasteStack(x, y, self)
            l.createText(stack, 's', text_format='%D')
            s.wastes.append(stack)
            x += l.XS

        # talon
        x, y = l.XM, l.YM
        s.talon = Well_TalonStack(x, y, self, max_rounds=5)
        l.createText(s.talon, "s")

        # define stack-groups
        self.sg.talonstacks = [s.talon] + s.wastes
        self.sg.openstacks = s.foundations + s.rows
        self.sg.dropstacks = s.rows + s.wastes + s.reserves