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, name, game_type, decks, redeals, skill_level):
game_type = game_type | GI.GT_HEXADECK
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
suits=list(range(4)), ranks=list(range(16)),
trumps=list(range(4)))
registerGame(gi)
return gi
def registerCustomGame(gameclass):
s = get_settings(gameclass.SETTINGS)
gameid = gameclass.SETTINGS['gameid']
registerGame(
GameInfo(gameid, gameclass, s['name'], GI.GT_CUSTOM | GI.GT_ORIGINAL,
s['decks'], s['redeals'], s['skill_level']))
def registerCustomGame(gameclass):
s = get_settings(gameclass.SETTINGS)
gameid = gameclass.SETTINGS['gameid']
registerGame(GameInfo(gameid, gameclass, s['name'],
GI.GT_CUSTOM | GI.GT_ORIGINAL,
s['decks'], s['redeals'], s['skill_level']))
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, 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, 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, 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_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_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_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, gameclass, name):
ncards = 0
for n in gameclass.ROWS:
ncards += n
ncards -= 1
gi = GameInfo(id, gameclass, name,
GI.GT_PUZZLE_TYPE, 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, 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 = classobj(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=range(3), ranks=range(ranks), trumps=range(trumps),
si={"decks": decks, "ncards": ncards})
gi.ncards = ncards
gi.rules_filename = "mahjongg.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
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
self.s.talon.dealRow(rows=[self.s.reserves[-1]], frames=0)
for i in range(3):
self.s.talon.dealRow(flip=0, frames=0)
self.startDealSample()
self.s.talon.dealRow()
self.s.talon.dealCards()
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(GameInfo(500, Madame, "Madame", GI.GT_TERRACE, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(533, MamySusan, "Mamy Susan", GI.GT_TERRACE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(582, Wood, "Wood", GI.GT_TERRACE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(637, BastilleDay, "Bastille Day", GI.GT_TERRACE, 2, 0, GI.SL_BALANCED))
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))
def startGame(self):
self.startDealSample()
i = 0
while self.s.talon.cards:
r = self.s.talon.cards[-1].rank
self.s.talon.dealRow(rows=[self.s.rows[i]], frames=4)
if r == ACE:
i += 1
shallHighlightMatch = Game._shallHighlightMatch_RK
# register the game
registerGame(GameInfo(141, DerKatzenschwanz, "Cat's Tail",
GI.GT_FREECELL | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=("Der Katzenschwanz",) ))
registerGame(GameInfo(142, DieSchlange, "Snake",
GI.GT_FREECELL | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=("Die Schlange",) ))
registerGame(GameInfo(279, Kings, "Kings",
GI.GT_FREECELL | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(286, Retinue, "Retinue",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(299, SalicLaw, "Salic Law",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(442, Deep, "Deep",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(523, Intrigue, "Intrigue",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(611, FaerieQueen, "Faerie Queen",
# ************************************************************************
# * Foothold
# ************************************************************************
class Foothold(FortyThieves):
RowStack_Class = UD_AC_RowStack
DEAL = (0, 5)
def createGame(self):
FortyThieves.createGame(self, rows=8, playcards=16)
shallHighlightMatch = Game._shallHighlightMatch_AC
# register the game
registerGame(GameInfo(13, FortyThieves, "Forty Thieves",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=("Napoleon at St.Helena",
"Le Cadran")))
registerGame(GameInfo(80, BusyAces, "Busy Aces",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(228, Limited, "Limited",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(79, WaningMoon, "Waning Moon",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(125, Lucas, "Lucas",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(109, Deuces, "Deuces",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(196, Corona, "Corona",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(195, Quadrangle, "Quadrangle",
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
EightPacks.createGame(self, max_rounds=2, width=12, playcards=18)
def isGameWon(self):
if self.s.talon.cards or self.s.waste.cards:
return False
for s in self.s.rows:
if s.cards:
if s.cards[0].rank != ACE:
return False
if len(s.cards) != 26:
return False
return True
# register the game
registerGame(GameInfo(294, CurdsAndWhey, "Curds and Whey",
GI.GT_SPIDER | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(311, Dumfries, "Dumfries",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(312, Galloway, "Galloway",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(313, Robin, "Robin",
GI.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(348, Arachnida, "Arachnida",
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(349, MissMuffet, "Miss Muffet",
GI.GT_SPIDER | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(352, Nordic, "Nordic",
GI.GT_SPIDER | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(414, GermanPatience, "German Patience",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(415, BavarianPatience, "Bavarian Patience",
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=list(range(14)), trumps=list(range(22)))
registerGame(gi)
return gi
self.s.talon.dealRow(frames=0)
self.startDealSample()
self.s.talon.dealRow()
def shallHighlightMatch(self, stack1, card1, stack2, card2):
if card1.rank != ACE and card2.rank != ACE:
# by rank
return abs(card1.rank-card2.rank) == 2
return card1.rank == ACE and card2.rank == ACE
getQuickPlayScore = Game._getSpiderQuickPlayScore
# register the game
registerGame(GameInfo(10, RelaxedSpider, "Relaxed Spider",
GI.GT_SPIDER | GI.GT_RELAXED, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(11, Spider, "Spider",
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(49, BlackWidow, "Black Widow",
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=("Scarab",) ))
registerGame(GameInfo(14, GroundsForADivorce, "Grounds for a Divorce",
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=('Scheidungsgrund',) ))
registerGame(GameInfo(114, GrandmothersGame, "Grandmother's Game",
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(24, Spiderette, "Spiderette",
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(47, BabySpiderette, "Baby Spiderette",
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(48, WillOTheWisp, "Will o' the Wisp",
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))
# * 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))
# ************************************************************************
class DoubleDojoujisGame(DojoujisGame):
MAX_ROW = 16
def Max_Cards(self, i):
return 16
def Deal_Rows(self, i):
return 16
# register the game
registerGame(GameInfo(13001, KatrinasGame, "Katrina's Game",
GI.GT_TAROCK, 2, 1, GI.SL_BALANCED,
ranks = range(14), trumps = range(22)))
registerGame(GameInfo(13002, BridgetsGame, "Bridget's Game",
GI.GT_HEXADECK, 2, 1, GI.SL_BALANCED,
ranks = range(16), trumps = range(4)))
registerGame(GameInfo(13003, FatimehsGame, "Fatimeh's Game",
GI.GT_MUGHAL_GANJIFA, 1, 2, GI.SL_BALANCED,
suits = range(8), ranks = range(12)))
registerGame(GameInfo(13004, KalisGame, "Kali's Game",
GI.GT_DASHAVATARA_GANJIFA, 1, 2, GI.SL_BALANCED,
suits = range(10), ranks = range(12)))
registerGame(GameInfo(13005, DojoujisGame, "Dojouji's Game",
GI.GT_HANAFUDA, 2, 0, GI.SL_BALANCED,
suits = range(12), ranks = range(4)))
registerGame(GameInfo(13008, RelaxedKatrinasGame, "Katrina's Game Relaxed",
GI.GT_TAROCK, 2, 1, GI.SL_BALANCED,
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))
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))
def startGame(self):
for i in range(4):
self.s.talon.dealRow(frames=0)
self.startDealSample()
self.s.talon.dealRow()
self.s.talon.dealRow(rows=self.s.reserves)
shallHighlightMatch = Game._shallHighlightMatch_RK
getQuickPlayScore = Game._getSpiderQuickPlayScore
# register the game
registerGame(GameInfo(1, Gypsy, "Gypsy",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(65, Giant, "Giant",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(3, Irmgard, "Irmgard",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(119, DieKoenigsbergerin, "Die Koenigsbergerin",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(174, DieRussische, "Russian Patience",
GI.GT_2DECK_TYPE | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL,
ranks=(0, 6, 7, 8, 9, 10, 11, 12),
altnames=("Die Russische",) ))
registerGame(GameInfo(62, MissMilligan, "Miss Milligan",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(200, Nomad, "Nomad",
GI.GT_GYPSY | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(78, MilliganCell, "Milligan Cell",
def startGame(self):
self.startDealSample()
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))
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=list(range(8)), ranks=list(range(12)))
registerGame(gi)
return gi
self.startDealSample()
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,
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(
def startGame(self):
self.base_card = self.s.talon.cards[-1]
for s in self.s.foundations:
s.cap.base_rank = self.base_card.rank
# deal base card to Foundations
c = self.s.talon.getCard()
to_stack = self.s.foundations[c.suit * self.gameinfo.decks]
self.flipMove(self.s.talon)
self.moveMove(1, self.s.talon, to_stack, frames=0)
# deal rows
self._startAndDealRowAndCards()
def _restoreGameHook(self, game):
self.base_card = self.cards[game.loadinfo.base_card_id]
for s in self.s.foundations:
s.cap.base_rank = self.base_card.rank
def _loadGameHook(self, p):
self.loadinfo.addattr(base_card_id=None) # register extra load var.
self.loadinfo.base_card_id = p.load()
def _saveGameHook(self, p):
p.dump(self.base_card.id)
shallHighlightMatch = Game._shallHighlightMatch_RKW
# register the game
registerGame(GameInfo(93, RoyalEast, "Royal East",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))
self.s.talon.dealCards()
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(
from_stack = self.s.reserves[0]
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))
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",
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",
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))
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",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0,
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,
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)
shallHighlightMatch = Game._shallHighlightMatch_RKW
# register the game
registerGame(GameInfo(330, Sultan, "Sultan",
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK,
altnames=("Sultan of Turkey",) ))
registerGame(GameInfo(331, SultanPlus, "Sultan +",
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(354, Boudoir, "Boudoir",
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(410, CaptiveQueens, "Captive Queens",
GI.GT_1DECK_TYPE, 1, 2, GI.SL_MOSTLY_LUCK,
altnames=("Quadrille",) ))
registerGame(GameInfo(418, Contradance, "Contradance",
GI.GT_2DECK_TYPE, 2, 1, GI.SL_LUCK,
altnames=("Cotillion",) ))
registerGame(GameInfo(419, IdleAces, "Idle Aces",
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(423, LadyOfTheManor, "Lady of the Manor",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK,
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",
shallHighlightMatch = Game._shallHighlightMatch_AC
class PairFcFreeCell(FreeCell):
def createGame(self):
FreeCell.createGame(self, reserves=2)
class ZeroFcFreeCell(FreeCell):
def createGame(self):
FreeCell.createGame(self, reserves=0)
# register the game
registerGame(GameInfo(5, RelaxedFreeCell, "Relaxed FreeCell",
GI.GT_FREECELL | GI.GT_RELAXED | GI.GT_OPEN, 1, 0,
GI.SL_SKILL))
registerGame(GameInfo(8, FreeCell, "FreeCell",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(1901, ZeroFcFreeCell, "FreeCell with Zero Reserves",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(1900, PairFcFreeCell, "FreeCell with Two Reserves",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(46, ForeCell, "ForeCell",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(77, Stalactites, "Stalactites",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("Grampus", "Old Mole")))
registerGame(GameInfo(264, DoubleFreecell, "Double FreeCell",
GI.GT_FREECELL | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(265, TripleFreecell, "Triple FreeCell",
class PokerShuffle(PokerSquare):
Talon_Class = InitialDealTalonStack
RowStack_Class = StackWrapper(PokerShuffle_RowStack, max_accept=1, max_cards=2)
WIN_SCORE = 200
def createGame(self):
l = 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}))
l.createText(s.talon, 'n')
x -= l.XS
s.waste = WasteStack(x, y, self)
l.createText(s.waste, 'n')
# define stack-groups
l.defaultStackGroups()
def startGame(self):
self._startDealNumRowsAndDealRowAndCards(4)
shallHighlightMatch = Game._shallHighlightMatch_AC
# register the game
registerGame(GameInfo(290, Bisley, "Bisley",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(372, DoubleBisley, "Double Bisley",
GI.GT_2DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL,
2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(373, Gloria, "Gloria",
GI.GT_2DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL,
2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(374, Realm, "Realm",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL,
1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(375, Mancunian, "Mancunian",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL,
1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(686, HospitalPatience, "Hospital Patience",
GI.GT_1DECK_TYPE, 1, -1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(692, BoardPatience, "Board Patience",
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,
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", )))
shallHighlightMatch = Game._shallHighlightMatch_AC
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, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(555, Quartets, "Quartets",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0,
GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(703, FourByFour, "Four by Four",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(740, Footling, "Footling",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0,
# ************************************************************************
# * 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,
# 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))
self.loadinfo.addattr(peaks=[0]*3)
self.loadinfo.peaks = p.load()
def _saveGameHook(self, p):
p.dump(self.game_score)
p.dump(self.hand_score)
p.dump(self.sequence)
p.dump(self.peaks)
# ************************************************************************
# * Three Peaks Game Non-scoring
# ************************************************************************
class ThreePeaksNoScore(ThreePeaks):
SCORING = 0
def canUndo(self):
return True
registerGame(GameInfo(22216, ThreePeaks, "Three Peaks",
GI.GT_PAIRING_TYPE | GI.GT_SCORE, 1, 0, GI.SL_BALANCED,
altnames=("Tri Peaks",)
))
registerGame(GameInfo(22231, ThreePeaksNoScore, "Three Peaks Non-scoring",
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_BALANCED))
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,
l.defaultStackGroups()
#
# 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()
self.s.talon.dealRow()
self.s.talon.dealCards()
def fillStack(self, stack):
if stack in self.s.rows and not stack.cards:
if self.s.reserves[0].cards:
old_state = self.enterState(self.S_FILL)
self.s.reserves[0].moveMove(1, stack)
self.leaveState(old_state)
shallHighlightMatch = Game._shallHighlightMatch_AC
# register the game
registerGame(GameInfo(105, Canfield, "Canfield", # was: 262
GI.GT_CANFIELD | GI.GT_CONTRIB, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(101, SuperiorCanfield, "Superior Canfield",
GI.GT_CANFIELD, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(99, Rainfall, "Rainfall",
GI.GT_CANFIELD | GI.GT_ORIGINAL, 1, 2, GI.SL_BALANCED))
registerGame(GameInfo(108, Rainbow, "Rainbow",
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(100, Storehouse, "Storehouse",
GI.GT_CANFIELD, 1, 2, GI.SL_BALANCED,
altnames=("Provisions", "Straight Up", "Thirteen Up")))
registerGame(GameInfo(43, Chameleon, "Chameleon",
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED,
altnames="Kansas"))
registerGame(GameInfo(106, DoubleCanfield, "Double Canfield", # was: 22
GI.GT_CANFIELD, 2, -1, GI.SL_BALANCED))
registerGame(GameInfo(103, AmericanToad, "American Toad",
self.s.talon.dealRow(flip=False)
self.flipMove(self.s.rows[-1])
self.s.rows[-1]._fillStack()
def isGameWon(self):
for r in self.s.rows:
if not r.cards[-1].face_up:
return False
return True
def getHighlightPilesStacks(self):
return ()
def getAutoStacks(self, event=None):
return (), (), ()
# register the game
registerGame(GameInfo(261, GrandfathersClock, "Grandfather's Clock",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(682, Dial, "Dial",
GI.GT_1DECK_TYPE, 1, 1, GI.SL_LUCK))
registerGame(GameInfo(690, Hemispheres, "Hemispheres",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED,
altnames=("The Four Continents",)))
registerGame(GameInfo(697, BigBen, "Big Ben",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(737, Clock, "Clock",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK,
altnames=("Travellers",)))
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))
registerGame(GameInfo(189, Queenie, "Queenie",
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(190, Rushdike, "Rushdike",
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
))
# ************************************************************************
# * 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,
altnames=("Idle Year", "Methuselah", "Tower of Babel"),
)
