def r(id, gameclass, name, rules_filename="shisensho.html"): decks, ranks, trumps = comp_cardset(gameclass.NCARDS) gi = GameInfo(id, gameclass, name, GI.GT_SHISEN_SHO, 4*decks, 0, GI.SL_MOSTLY_SKILL, category=GI.GC_MAHJONGG, short_name=name, suits=range(3), ranks=range(ranks), trumps=range(trumps), si={"decks": decks, "ncards": gameclass.NCARDS}) gi.ncards = gameclass.NCARDS gi.rules_filename = rules_filename registerGame(gi) return gi
def r(id, gameclass, name): ncards = 0 for n in gameclass.ROWS: ncards += n gi = GameInfo(id, gameclass, name, GI.GT_PEGGED, 1, 0, GI.SL_SKILL, category=GI.GC_TRUMP_ONLY, suits=(), ranks=(), trumps=list(range(ncards)), si={"decks": 1, "ncards": ncards}, rules_filename="pegged.html") registerGame(gi) return gi
def r(id, gameclass, name, game_type, decks, redeals, skill_level): game_type = game_type | GI.GT_MUGHAL_GANJIFA gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level, suits=range(8), ranks=range(12)) registerGame(gi) return gi
def r(id, gameclass, name, game_type, decks, redeals, skill_level): game_type = game_type | GI.GT_HANAFUDA gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level, suits=list(range(12)), ranks=list(range(4))) registerGame(gi) return gi
def r(id, gameclass, name, game_type, decks, redeals, skill_level): game_type = game_type | GI.GT_DASHAVATARA_GANJIFA gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level, suits=list(range(10)), ranks=list(range(12))) registerGame(gi) return gi
def r(id, gameclass, name, game_type, decks, redeals, skill_level): game_type = game_type | GI.GT_TAROCK | GI.GT_CONTRIB | GI.GT_ORIGINAL gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level, ranks=range(14), trumps=range(22)) registerGame(gi) return gi
def r(id, short_name, name=None, ncards=144, layout=None): assert layout if not name: name = "Mahjongg " + short_name classname = re.sub('\\W', '', name) # create class gameclass = type(classname, (AbstractMahjonggGame,), {}) gameclass.L = layout gameclass.NCARDS = ncards decks, ranks, trumps = comp_cardset(ncards) gi = GameInfo(id, gameclass, name, GI.GT_MAHJONGG, 4*decks, 0, # GI.SL_MOSTLY_SKILL, category=GI.GC_MAHJONGG, short_name=short_name, suits=list(range(3)), ranks=list(range(ranks)), trumps=list(range(trumps)), si={"decks": decks, "ncards": ncards}) gi.ncards = ncards gi.rules_filename = "mahjongg.html" registerGame(gi) return gi
def r(id, gameclass, short_name): name = short_name ncards = int(name[:2]) * int(name[:2]) gi = GameInfo(id, gameclass, name, GI.GT_MATRIX, 1, 0, GI.SL_SKILL, category=GI.GC_TRUMP_ONLY, short_name=short_name, suits=(), ranks=(), trumps=range(ncards), si={ "decks": 1, "ncards": ncards }) gi.ncards = ncards gi.rules_filename = "matrix.html" registerGame(gi) return gi
def r(id, short_name, width): name = short_name ncards = width**2 gi = GameInfo(id, LightsOut, name, GI.GT_LIGHTS_OUT, 1, 0, GI.SL_SKILL, category=GI.GC_TRUMP_ONLY, short_name=short_name, suits=(), ranks=(), trumps=list(range(ncards)), si={ "decks": 1, "ncards": ncards }) gi.ncards = ncards gi.rules_filename = "lightsout.html" registerGame(gi) return gi
class PokerShuffle(PokerSquare): Talon_Class = InitialDealTalonStack RowStack_Class = StackWrapper( PokerShuffle_RowStack, max_accept=1, max_cards=2) WIN_SCORE = 200 def createGame(self): PokerSquare.createGame(self) if self.s.talon.texts.ncards: self.s.talon.texts.ncards.text_format = "%D" def startGame(self): self.moveMove(27, self.s.talon, self.s.internals[0], frames=0) self.startDealSample() self.s.talon.dealRow() def checkForWin(self): return 0 # register the game registerGame(GameInfo(139, PokerSquare, "Poker Square", GI.GT_POKER_TYPE | GI.GT_SCORE, 1, 0, GI.SL_MOSTLY_SKILL, si={"ncards": 25})) registerGame(GameInfo(140, PokerShuffle, "Poker Shuffle", GI.GT_POKER_TYPE | GI.GT_SCORE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL, si={"ncards": 25}))
for i in range(2): self.s.talon.dealRow(rows=self.s.reserves, frames=0) self.startDealSample() self.s.talon.dealRow(rows=self.s.reserves) self.s.talon.dealRow() def fillStack(self, stack): if stack in self.s.rows and not stack.cards and self.s.talon.cards: old_state = self.enterState(self.S_FILL) self.s.talon.flipMove() self.s.talon.moveMove(1, stack) self.leaveState(old_state) # register the game registerGame(GameInfo(38, Pyramid, "Pyramid", GI.GT_PAIRING_TYPE, 1, 2, GI.SL_MOSTLY_LUCK)) registerGame(GameInfo(193, RelaxedPyramid, "Relaxed Pyramid", GI.GT_PAIRING_TYPE | GI.GT_RELAXED, 1, 2, GI.SL_MOSTLY_LUCK, altnames=(" Pyramid's Stones",))) # registerGame(GameInfo(44, Thirteen, "Thirteen", # GI.GT_PAIRING_TYPE, 1, 0)) registerGame(GameInfo(592, Giza, "Giza", GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED)) registerGame(GameInfo(593, Thirteens, "Thirteens", GI.GT_PAIRING_TYPE, 1, 0, GI.SL_LUCK)) registerGame(GameInfo(594, Elevens, "Elevens", GI.GT_PAIRING_TYPE, 1, 0, GI.SL_LUCK)) registerGame(GameInfo(595, ElevensToo, "Elevens Too", GI.GT_PAIRING_TYPE, 1, 0, GI.SL_LUCK)) registerGame(GameInfo(596, SuitElevens, "Suit Elevens",
def getQuickPlayScore(self, ncards, from_stack, to_stack): return int(to_stack in self.s.rows) # ************************************************************************ # * Penelope's Web # ************************************************************************ class PenelopesWeb(StreetsAndAlleys): RowStack_Class = StackWrapper(RK_RowStack, base_rank=KING) Solver_Class = FreeCellSolverWrapper(sbb='rank', esf='kings') # register the game registerGame(GameInfo(146, StreetsAndAlleys, "Streets and Alleys", GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)) registerGame(GameInfo(34, BeleagueredCastle, "Beleaguered Castle", GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL, altnames=("Laying Siege", "Sham Battle",))) registerGame(GameInfo(145, Citadel, "Citadel", GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)) registerGame(GameInfo(147, Fortress, "Fortress", GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_SKILL)) registerGame(GameInfo(148, Chessboard, "Chessboard", GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_SKILL)) registerGame(GameInfo(300, Stronghold, "Stronghold",
return self._shuffleHookMoveToTop(cards, lambda c: (c.rank == ACE, c.suit)) def startGame(self): self.s.talon.dealRow(rows=self.s.foundations, frames=0) self._startDealNumRows(4) self.s.talon.dealRowAvail() self.s.talon.dealRowAvail() # register the game registerGame( GameInfo(257, Numerica, "Numerica", GI.GT_NUMERICA | GI.GT_CONTRIB, 1, 0, GI.SL_BALANCED, altnames=("Sir Tommy", ))) registerGame( GameInfo(171, LadyBetty, "Lady Betty", GI.GT_NUMERICA, 1, 0, GI.SL_BALANCED)) registerGame(GameInfo(355, Frog, "Frog", GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(356, Fly, "Fly", GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED,
def dealCards(self, sound=True): # for demo-mode if self.demo: r = self.s.reserves[0] if r.canDealCards(): # self.demo.last_deal = [] # don't check last deal return r.dealCards(sound=sound) return Game.dealCards(self, sound=sound) shallHighlightMatch = Game._shallHighlightMatch_AC # register the game registerGame( GameInfo(135, Terrace, "Terrace", GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(136, GeneralsPatience, "General's Patience", GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_LUCK)) registerGame( GameInfo(137, BlondesAndBrunettes, "Blondes and Brunettes", GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_LUCK)) registerGame( GameInfo(138, FallingStar, "Falling Star", GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_LUCK)) registerGame( GameInfo(431, QueenOfItaly, "Queen of Italy", GI.GT_TERRACE, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(499, Signora, "Signora", GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_SKILL)) registerGame(
class DoubleFootling(Footling): def createGame(self): Footling.createGame(self, rows=10, reserves=5, playcards=18) def startGame(self): self._startDealNumRows(9) self.s.talon.dealRow() self.s.talon.dealRowAvail() # register the game registerGame( GameInfo(41, PileOn, "PileOn", GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL, altnames=("Fifteen Puzzle", ))) registerGame( GameInfo(289, SmallPileOn, "Small PileOn", GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL, ranks=(0, 5, 6, 7, 8, 9, 10, 11, 12), rules_filename="pileon.html")) registerGame( GameInfo(554, Foursome, "Foursome", GI.GT_1DECK_TYPE, 1, 0,
# define stack-groups l.defaultStackGroups() # # game overrides # def isGameWon(self): return len(self.s.talon.cards) == 0 and len(self.s.waste.cards) == 0 def getAutoStacks(self, event=None): return ((), (), ()) def shallHighlightMatch(self, stack1, card1, stack2, card2): return card1.rank + card2.rank == 12 # ************************************************************************ # * Strict Eiffel Tower # ************************************************************************ class StrictEiffelTower(EiffelTower): Waste_Class = StackWrapper(WasteStack, max_cards=2) # register the game registerGame(GameInfo(16, EiffelTower, "Eiffel Tower", GI.GT_PAIRING_TYPE, 2, 0, GI.SL_MOSTLY_LUCK)) # registerGame(GameInfo(801, StrictEiffelTower, "Strict Eiffel Tower", # GI.GT_PAIRING_TYPE, 2, 0))
def getAutoStacks(self, event=None): return ((), (), (self.sg.dropstacks)) def isGameWon(self): for r in self.s.rows: if len(r.cards) != 1: return False c = r.cards[-1] if c.suit != r.id / 13 or c.rank != r.id % 13: return False return True # # game extras # def isNeighbour(self, stack1, stack2): column1, row1 = stack1.id % 13, stack1.id / 13 column2, row2 = stack2.id % 13, stack2.id / 13 return column1 == column2 or row1 == row2 def getHighlightPilesStacks(self): # Pas de Deux special: highlight all moveable cards return ((self.s.rows, 1), ) # register the game registerGame( GameInfo(153, PasDeDeux, "Pas de Deux", GI.GT_MONTANA | GI.GT_SEPARATE_DECKS, 2, 1, GI.SL_MOSTLY_SKILL))
def createGame(self): DoubleKlondike.createGame(self, rows=10, max_rounds=1) def startGame(self): self._startDealNumRows(3) self.s.talon.dealRow() self.s.talon.dealCards() # deal first card to WasteStack shallHighlightMatch = Game._shallHighlightMatch_RK getQuickPlayScore = Game._getSpiderQuickPlayScore # register the game registerGame( GameInfo(21, DoubleKlondike, "Double Klondike", GI.GT_KLONDIKE, 2, -1, GI.SL_BALANCED)) registerGame( GameInfo(28, DoubleKlondikeByThrees, "Double Klondike by Threes", GI.GT_KLONDIKE, 2, -1, GI.SL_MOSTLY_LUCK)) registerGame( GameInfo(25, Gargantua, "Gargantua", GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED)) registerGame( GameInfo(15, BigHarp, "Big Harp", GI.GT_KLONDIKE, 2, 0, GI.SL_BALANCED)) registerGame(GameInfo(51, Steps, "Steps", GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED)) registerGame( GameInfo(273, TripleKlondike, "Triple Klondike", GI.GT_KLONDIKE, 3, -1, GI.SL_BALANCED)) registerGame( GameInfo(274, TripleKlondikeByThrees, "Triple Klondike by Threes", GI.GT_KLONDIKE, 3, -1, GI.SL_MOSTLY_LUCK))
n = (104 - reserves - 2 * rows) // (reserves // 2) for i in range(n): self.s.talon.dealRow(rows=self.s.reserves2, frames=0, flip=0) self.s.talon.dealRow(rows=self.s.reserves, frames=0) self.startDealSample() self.s.talon.dealRow() self.s.talon.dealRow() def fillStack(self, stack): if stack in self.s.reserves and not stack.cards: si = list(self.s.reserves).index(stack) from_stack = self.s.reserves2[si // 2] if not from_stack.cards: return old_state = self.enterState(self.S_FILL) from_stack.flipMove() from_stack.moveMove(1, stack) self.leaveState(old_state) shallHighlightMatch = Game._shallHighlightMatch_AC # register the game registerGame( GameInfo(307, HeadsAndTails, "Heads and Tails", GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(708, Barrier, "Barrier", GI.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0, GI.SL_BALANCED))
self.s.talon.dealRow() self.s.talon.dealCards() def fillStack(self, stack): if stack in self.s.rows and not stack.cards: old_state = self.enterState(self.S_FILL) if not self.s.waste.cards: self.s.talon.dealCards() if self.s.waste.cards: self.s.waste.moveMove(1, stack) self.leaveState(old_state) # register the game registerGame( GameInfo(280, Camelot, "Camelot", GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(610, SlyFox, "Sly Fox", GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(614, OpenSlyFox, "Open Sly Fox", GI.GT_NUMERICA | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(623, PrincessPatience, "Princess Patience", GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(622, GrandmammasPatience, "Grandmamma's Patience", GI.GT_NUMERICA, 2, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(702, DoubleLine, "Double Line", GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED))
top.append(c) top.sort(lambda a, b: cmp(b.rank, a.rank)) return cards + top[7:] + top[:7] def startGame(self): self.startDealSample() self.s.talon.dealRow(rows=self.s.foundations) self.s.talon.dealCards() # register the game registerGame( GameInfo(256, Calculation, "Calculation", GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL, altnames=("Progression", ))) registerGame( GameInfo(94, Hopscotch, "Hopscotch", GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(134, BetsyRoss, "Betsy Ross", GI.GT_1DECK_TYPE, 1, 2, GI.SL_MOSTLY_LUCK, altnames=("Fairest", "Four Kings", "Musical Patience",
# * play similar to Yukon # ************************************************************************ class Sanibel(Gypsy): Layout_Method = staticmethod(Layout.klondikeLayout) Talon_Class = StackWrapper(WasteTalonStack, max_rounds=1) Foundation_Class = StackWrapper(SS_FoundationStack, max_move=0) RowStack_Class = Yukon_AC_RowStack Hint_Class = Yukon_Hint def createGame(self): Gypsy.createGame(self, rows=10, waste=1, playcards=23) def startGame(self): for i in range(3): self.s.talon.dealRow(flip=0, frames=0) for i in range(6): self.s.talon.dealRow(frames=0) self.startDealSample() self.s.talon.dealRow() self.s.talon.dealCards() # deal first card to WasteStack def getHighlightPilesStacks(self): return () registerGame(GameInfo(201, Sanibel, "Sanibel", GI.GT_YUKON | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
self.rank = game.loadinfo.dval.get('Rank') self.deadDeals = game.loadinfo.dval.get('DeadDeals') def _loadGameHook(self, p): self.loadinfo.addattr(dval=p.load()) def _saveGameHook(self, p): dval = {'Rank': self.rank, 'DeadDeals': self.deadDeals} p.dump(dval) def setState(self, state): # restore saved vars (from undo/redo) self.rank = state[0] self.deadDeals = state[1] def getState(self): # save vars (for undo/redo) return [self.rank, self.deadDeals] # register the game registerGame( GameInfo(774, HitOrMiss, "Hit or Miss", GI.GT_1DECK_TYPE, 1, VARIABLE_REDEALS, GI.SL_LUCK, altnames=("Roll Call", )))
self.fillStack() game.updateStackMove(game.s.talon, 1 | 16) # for redo game.leaveState(old_state) clickHandler = ReserveStack.clickHandler class Decade(PushPin): Hint_Class = Decade_Hint RowStack_Class = Decade_RowStack def isGameWon(self): return len(self.s.foundations[0].cards) == 52 registerGame(GameInfo(287, PushPin, "Push Pin", GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) registerGame(GameInfo(288, RoyalMarriage, "Royal Marriage", GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) # registerGame(GameInfo(303, Queens, "Queens", # GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0)) registerGame(GameInfo(656, Accordion, "Bayan", GI.GT_1DECK_TYPE, 1, 0, GI.SL_SKILL)) registerGame(GameInfo(772, Accordion2, "Accordion", GI.GT_1DECK_TYPE, 1, 0, GI.SL_SKILL, altnames=('Idle Year', 'Methuselah', 'Tower of Babel'))) registerGame(GameInfo(773, RelaxedAccordion, "Relaxed Accordion", GI.GT_1DECK_TYPE | GI.GT_RELAXED, 1, 0, GI.SL_SKILL)) registerGame(GameInfo(811, AccordionsRevenge, "Accordion's Revenge", GI.GT_1DECK_TYPE, 1, 0, GI.SL_SKILL)) registerGame(GameInfo(816, Decade, "Decade", GI.GT_1DECK_TYPE, 1, 0, GI.SL_SKILL,
# ************************************************************************ # * Relaxed Accordion # ************************************************************************ class RelaxedAccordion_RowStack(Accordion2_RowStack): acceptsCards = Accordion_RowStack.acceptsCards class RelaxedAccordion(Accordion2): RowStack_Class = RelaxedAccordion_RowStack registerGame( GameInfo(287, PushPin, "Push Pin", GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) registerGame( GameInfo(288, RoyalMarriage, "Royal Marriage", GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) ## registerGame(GameInfo(303, Queens, "Queens", ## GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0)) registerGame( GameInfo(656, Accordion, "Bayan", GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(772, Accordion2, "Accordion", GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED,
SS_FoundationStack(r.x, r.y, self, suit=r.suit)) for r in l.s.rows: s.rows.append(Yukon_AC_RowStack(r.x, r.y, self)) l.defaultAll() def startGame(self): self.s.talon.dealRow(frames=0) self.s.talon.dealRow(frames=0, flip=0) self.startDealSample() self.s.talon.dealRow() shallHighlightMatch = Game._shallHighlightMatch_AC # register the game registerGame(GameInfo(19, Yukon, "Yukon", GI.GT_YUKON, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(20, RussianSolitaire, "Russian Solitaire", GI.GT_YUKON, 1, 0, GI.SL_BALANCED)) registerGame(GameInfo(27, Odessa, "Odessa", GI.GT_YUKON, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(278, Grandfather, "Grandfather", GI.GT_YUKON, 1, 2, GI.SL_BALANCED)) registerGame(GameInfo(186, Alaska, "Alaska", GI.GT_YUKON, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(187, ChineseDiscipline, "Chinese Discipline", GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(188, ChineseSolitaire, "Chinese Solitaire", GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
if from_stack.cards: from_stack.flipMove() from_stack.moveMove(1, stack) self.leaveState(old_state) shallHighlightMatch = Game._shallHighlightMatch_SS def getQuickPlayScore(self, ncards, from_stack, to_stack): if to_stack in self.s.xwastes: return 0 return 1 + Game.getQuickPlayScore(self, ncards, from_stack, to_stack) # register the game registerGame( GameInfo(42, Bristol, "Bristol", GI.GT_FAN_TYPE, 1, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(214, Belvedere, "Belvedere", GI.GT_FAN_TYPE, 1, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(266, Dover, "Dover", GI.GT_FAN_TYPE, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(425, NewYork, "New York", GI.GT_FAN_TYPE, 2, 0, GI.SL_MOSTLY_SKILL)) registerGame( GameInfo(468, Spike, "Spike", GI.GT_KLONDIKE, 1, 0, GI.SL_BALANCED)) registerGame( GameInfo(519, Gotham, "Gotham", GI.GT_FAN_TYPE, 2, 0, GI.SL_BALANCED)) registerGame( GameInfo(604, Interment, "Interment", GI.GT_FAN_TYPE, 2, 0, GI.SL_BALANCED))
# # game extras # def cardsMatch(self, card1, card2): return card1.rank == card2.rank # register the game registerGame( GameInfo(176, Memory24, "Memory 24", GI.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL, suits=(0, 2), ranks=(0, 8, 9, 10, 11, 12))) registerGame( GameInfo(219, Memory30, "Memory 30", GI.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL, suits=(0, 2, 3), ranks=(0, 9, 10, 11, 12))) registerGame(
self.startDealSample() for i in range(3): rows = self.s.tableaux[i * 8 + 1:i * 8 + 8] self.s.talon.dealRow(rows=rows) self.s.talon.dealRow() def fillStack(self, stack): pass # register the game registerGame( GameInfo(7, PictureGallery, "Picture Gallery", GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED, altnames=("Die Bildgallerie", "Mod-3"))) registerGame( GameInfo( 397, GreatWheel, "Great Wheel", GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED, ranks=range(12) # without Kings )) registerGame(
class Manx(TabbyCat): ReserveStack_Class = ReserveStack class MaineCoon(TabbyCat): def createGame(self): TabbyCat.createGame(self, playcards=26) # register the game registerGame( GameInfo( 903, AcesUp, "Aces Up", # was: 52 GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK, altnames=("Aces High", "Drivel"))) registerGame( GameInfo(206, Fortunes, "Fortunes", GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK)) registerGame( GameInfo(213, RussianAces, "Russian Aces", GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK)) registerGame( GameInfo(130, PerpetualMotion, "Perpetual Motion", GI.GT_1DECK_TYPE, 1,