anthonycicc/PySolFC
1
0
Fork 0
mirror of https://github.com/shlomif/PySolFC.git synced 2025-04-05 00:02:29 -04:00
Code Releases Activity

flake8 - games/p*

Browse source
This commit is contained in:
Shlomi Fish 2017-04-18 02:23:26 +03:00
parent 2cd0df484d
commit 84018dbfe2
7 changed files with 234 additions and 154 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
pysollib/games/parallels.py
View file

@ -24,22 +24,25 @@
__all__ = [] __all__ = []
# imports # imports
import sys
# PySol imports # PySol imports
from pysollib.gamedb import registerGame, GameInfo, GI from pysollib.gamedb import registerGame, GameInfo, GI
from pysollib.util import *
from pysollib.stack import *
from pysollib.game import Game from pysollib.game import Game
from pysollib.layout import Layout from pysollib.layout import Layout
from pysollib.hint import AbstractHint, DefaultHint, CautiousDefaultHint
from pysollib.util import ACE, KING
from pysollib.stack import \
BasicRowStack, \
DealRowTalonStack, \
SS_FoundationStack
# ************************************************************************ # ************************************************************************
# * Parallels # * Parallels
# * British Blockade # * British Blockade
# ************************************************************************ # ************************************************************************
class Parallels_RowStack(BasicRowStack): class Parallels_RowStack(BasicRowStack):
def basicIsBlocked(self): def basicIsBlocked(self):
index = self.index index = self.index
@ -60,8 +63,9 @@ class Parallels_TalonStack(DealRowTalonStack):
return self.dealRow(sound=sound) return self.dealRow(sound=sound)
def dealRow(self, rows=None, flip=1, reverse=0, frames=-1, sound=False): def dealRow(self, rows=None, flip=1, reverse=0, frames=-1, sound=False):
if not rows is None: if rows is not None:
return DealRowTalonStack.dealRowAvail(self, rows=rows, flip=flip, return DealRowTalonStack.dealRowAvail(
self, rows=rows, flip=flip,
reverse=reverse, frames=frames, sound=sound) reverse=reverse, frames=frames, sound=sound)
rows = self.game.s.rows rows = self.game.s.rows
for r in rows[:10]: for r in rows[:10]:
@ -75,7 +79,8 @@ class Parallels_TalonStack(DealRowTalonStack):
if max(column_ncards) != min(column_ncards): if max(column_ncards) != min(column_ncards):
return self._fillRow(frames=frames, sound=sound) return self._fillRow(frames=frames, sound=sound)
r = rows[max_col*10:max_col*10+10] r = rows[max_col*10:max_col*10+10]
return DealRowTalonStack.dealRowAvail(self, rows=r, flip=flip, return DealRowTalonStack.dealRowAvail(
self, rows=r, flip=flip,
reverse=reverse, frames=frames, sound=sound) reverse=reverse, frames=frames, sound=sound)
def _fillRow(self, frames=-1, sound=False): def _fillRow(self, frames=-1, sound=False):
@ -98,7 +103,8 @@ class Parallels_TalonStack(DealRowTalonStack):
break break
if s.cards: if s.cards:
if prev_s: if prev_s:
DealRowTalonStack.dealRow(self, rows=[prev_s], DealRowTalonStack.dealRow(
self, rows=[prev_s],
frames=frames, sound=sound) frames=frames, sound=sound)
n += 1 n += 1
filled = True filled = True
@ -114,7 +120,8 @@ class Parallels_TalonStack(DealRowTalonStack):
filled = False filled = False
break break
if not s.cards: if not s.cards:
DealRowTalonStack.dealRow(self, rows=[s], DealRowTalonStack.dealRow(
self, rows=[s],
frames=frames, sound=sound) frames=frames, sound=sound)
n += 1 n += 1
filled = True filled = True
@ -160,7 +167,8 @@ class Parallels(Game):
l.defaultStackGroups() l.defaultStackGroups()
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
return self._shuffleHookMoveToTop(cards, return self._shuffleHookMoveToTop(
cards,
lambda c: (c.rank in (ACE, KING) and c.deck == 0, lambda c: (c.rank in (ACE, KING) and c.deck == 0,
(c.rank, c.suit))) (c.rank, c.suit)))
@ -186,8 +194,3 @@ registerGame(GameInfo(428, Parallels, "Parallels",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED)) GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(615, BritishBlockade, "British Blockade", registerGame(GameInfo(615, BritishBlockade, "British Blockade",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED)) GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

21
pysollib/games/pasdedeux.py
View file

@ -24,21 +24,24 @@
__all__ = [] __all__ = []
# imports # imports
import sys
# PySol imports # PySol imports
from pysollib.gamedb import registerGame, GameInfo, GI from pysollib.gamedb import registerGame, GameInfo, GI
from pysollib.util import *
from pysollib.stack import *
from pysollib.game import Game from pysollib.game import Game
from pysollib.layout import Layout from pysollib.layout import Layout
from pysollib.hint import AbstractHint, DefaultHint, CautiousDefaultHint from pysollib.hint import AbstractHint
from pysollib.stack import \
InvisibleStack, \
ReserveStack, \
WasteStack, \
WasteTalonStack
# ************************************************************************ # ************************************************************************
# * # *
# ************************************************************************ # ************************************************************************
class PasDeDeux_Hint(AbstractHint): class PasDeDeux_Hint(AbstractHint):
# FIXME: this is very simple # FIXME: this is very simple
@ -100,7 +103,8 @@ class PasDeDeux_RowStack(ReserveStack):
if not self.game.s.waste.cards: if not self.game.s.waste.cards:
return False return False
c = self.game.s.waste.cards[-1] c = self.game.s.waste.cards[-1]
return c.face_up and cards[0].suit == c.suit and cards[0].rank == c.rank return c.face_up and cards[0].suit == c.suit and \
cards[0].rank == c.rank
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not ReserveStack.acceptsCards(self, from_stack, cards): if not ReserveStack.acceptsCards(self, from_stack, cards):
@ -161,7 +165,8 @@ class PasDeDeux(Game):
for i in range(4): for i in range(4):
for j in range(13): for j in range(13):
x, y, = l.XM + j*l.XS, l.YM + i*l.YS x, y, = l.XM + j*l.XS, l.YM + i*l.YS
s.rows.append(PasDeDeux_RowStack(x, y, self, max_accept=1, max_cards=2)) s.rows.append(
PasDeDeux_RowStack(x, y, self, max_accept=1, max_cards=2))
x, y = self.width - 2*l.XS, self.height - l.YS x, y = self.width - 2*l.XS, self.height - l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=2) s.talon = WasteTalonStack(x, y, self, max_rounds=2)
l.createText(s.talon, "se") l.createText(s.talon, "se")
@ -214,5 +219,5 @@ class PasDeDeux(Game):
# register the game # register the game
registerGame(GameInfo(153, PasDeDeux, "Pas de Deux", registerGame(GameInfo(153, PasDeDeux, "Pas de Deux",
GI.GT_MONTANA | GI.GT_SEPARATE_DECKS, 2, 1, GI.SL_MOSTLY_SKILL)) GI.GT_MONTANA | GI.GT_SEPARATE_DECKS, 2, 1,
GI.SL_MOSTLY_SKILL))

77
pysollib/games/picturegallery.py
View file

@ -24,20 +24,32 @@
__all__ = [] __all__ = []
# imports # imports
import sys
# PySol imports # PySol imports
from pysollib.gamedb import registerGame, GameInfo, GI from pysollib.gamedb import registerGame, GameInfo, GI
from pysollib.util import *
from pysollib.stack import *
from pysollib.game import Game from pysollib.game import Game
from pysollib.layout import Layout from pysollib.layout import Layout
from pysollib.hint import AbstractHint, DefaultHint, CautiousDefaultHint from pysollib.hint import AbstractHint
from pysollib.util import ACE, KING, QUEEN
from pysollib.stack import \
BasicRowStack, \
DealRowTalonStack, \
InvisibleStack, \
RK_FoundationStack, \
SS_FoundationStack, \
SS_RowStack, \
Stack, \
StackWrapper, \
WasteStack, \
WasteTalonStack
# ************************************************************************ # ************************************************************************
# * # *
# ************************************************************************ # ************************************************************************
class PictureGallery_Hint(AbstractHint): class PictureGallery_Hint(AbstractHint):
def computeHints(self): def computeHints(self):
game = self.game game = self.game
@ -129,7 +141,8 @@ class PictureGallery_Hint(AbstractHint):
# this Foundation only accepts Aces # this Foundation only accepts Aces
class PictureGallery_Foundation(RK_FoundationStack): class PictureGallery_Foundation(RK_FoundationStack):
def __init__(self, x, y, game): def __init__(self, x, y, game):
RK_FoundationStack.__init__(self, x, y, game, base_rank=ACE, dir=0, max_move=0, max_cards=8) RK_FoundationStack.__init__(
self, x, y, game, base_rank=ACE, dir=0, max_move=0, max_cards=8)
self.CARD_YOFFSET = min(30, self.game.app.images.CARD_YOFFSET + 10) self.CARD_YOFFSET = min(30, self.game.app.images.CARD_YOFFSET + 10)
def getBottomImage(self): def getBottomImage(self):
@ -137,7 +150,8 @@ class PictureGallery_Foundation(RK_FoundationStack):
def closeStack(self): def closeStack(self):
if len(self.cards) == 8: if len(self.cards) == 8:
if self.game.moves.state not in (self.game.S_REDO, self.game.S_RESTORE): if self.game.moves.state not in \
(self.game.S_REDO, self.game.S_RESTORE):
self.game.flipAllMove(self) self.game.flipAllMove(self)
def canFlipCard(self): def canFlipCard(self):
@ -146,7 +160,8 @@ class PictureGallery_Foundation(RK_FoundationStack):
class PictureGallery_TableauStack(SS_RowStack): class PictureGallery_TableauStack(SS_RowStack):
def __init__(self, x, y, game, base_rank, yoffset, dir=3, max_cards=4): def __init__(self, x, y, game, base_rank, yoffset, dir=3, max_cards=4):
SS_RowStack.__init__(self, x, y, game, SS_RowStack.__init__(
self, x, y, game,
base_rank=base_rank, dir=dir, max_cards=max_cards, max_accept=1) base_rank=base_rank, dir=dir, max_cards=max_cards, max_accept=1)
self.CARD_YOFFSET = yoffset self.CARD_YOFFSET = yoffset
@ -182,9 +197,12 @@ class PictureGallery(Game):
Foundation_Class = PictureGallery_Foundation Foundation_Class = PictureGallery_Foundation
TableauStack_Classes = [ TableauStack_Classes = [
StackWrapper(PictureGallery_TableauStack, base_rank=3, max_cards=4, dir=3), StackWrapper(
StackWrapper(PictureGallery_TableauStack, base_rank=2, max_cards=4, dir=3), PictureGallery_TableauStack, base_rank=3, max_cards=4, dir=3),
StackWrapper(PictureGallery_TableauStack, base_rank=1, max_cards=4, dir=3), StackWrapper(
PictureGallery_TableauStack, base_rank=2, max_cards=4, dir=3),
StackWrapper(
PictureGallery_TableauStack, base_rank=1, max_cards=4, dir=3),
] ]
RowStack_Class = StackWrapper(PictureGallery_RowStack, max_accept=1) RowStack_Class = StackWrapper(PictureGallery_RowStack, max_accept=1)
Talon_Class = DealRowTalonStack Talon_Class = DealRowTalonStack
@ -221,7 +239,7 @@ class PictureGallery(Game):
for i in range(8): for i in range(8):
s.rows.append(self.RowStack_Class(x, y, self)) s.rows.append(self.RowStack_Class(x, y, self))
x = x + l.XS x = x + l.XS
##self.setRegion(s.rows, (-999, -999, x - l.CW / 2, 999999)) # self.setRegion(s.rows, (-999, -999, x - l.CW / 2, 999999))
x = l.XM + 8 * l.XS + l.XS / 2 x = l.XM + 8 * l.XS + l.XS / 2
y = self.height - l.YS y = self.height - l.YS
s.talon = self.Talon_Class(x, y, self) s.talon = self.Talon_Class(x, y, self)
@ -241,7 +259,6 @@ class PictureGallery(Game):
self.sg.talonstacks = [s.talon] + ws self.sg.talonstacks = [s.talon] + ws
self.sg.dropstacks = s.tableaux + s.rows + ws self.sg.dropstacks = s.tableaux + s.rows + ws
# #
# game overrides # game overrides
# #
@ -274,11 +291,11 @@ class PictureGallery(Game):
return () return ()
# ************************************************************************ # ************************************************************************
# * Great Wheel # * Great Wheel
# ************************************************************************ # ************************************************************************
class GreatWheel_Hint(PictureGallery_Hint): class GreatWheel_Hint(PictureGallery_Hint):
shallMovePile = PictureGallery_Hint._cautiousShallMovePile shallMovePile = PictureGallery_Hint._cautiousShallMovePile
@ -311,8 +328,10 @@ class GreatWheel(PictureGallery):
Hint_Class = GreatWheel_Hint Hint_Class = GreatWheel_Hint
Foundation_Class = GreatWheel_Foundation Foundation_Class = GreatWheel_Foundation
TableauStack_Classes = [ TableauStack_Classes = [
StackWrapper(PictureGallery_TableauStack, base_rank=2, max_cards=5, dir=2), StackWrapper(
StackWrapper(PictureGallery_TableauStack, base_rank=1, max_cards=6, dir=2), PictureGallery_TableauStack, base_rank=2, max_cards=5, dir=2),
StackWrapper(
PictureGallery_TableauStack, base_rank=1, max_cards=6, dir=2),
] ]
RowStack_Class = StackWrapper(GreatWheel_RowStack, max_accept=1) RowStack_Class = StackWrapper(GreatWheel_RowStack, max_accept=1)
Talon_Class = StackWrapper(WasteTalonStack, max_rounds=1) Talon_Class = StackWrapper(WasteTalonStack, max_rounds=1)
@ -339,7 +358,6 @@ class GreatWheel(PictureGallery):
self.s.talon.dealRow() self.s.talon.dealRow()
self.s.talon.dealCards() self.s.talon.dealCards()
def isGameWon(self): def isGameWon(self):
if len(self.s.foundations[0].cards) != 8: if len(self.s.foundations[0].cards) != 8:
return False return False
@ -350,7 +368,6 @@ class GreatWheel(PictureGallery):
return False return False
return True return True
def shallHighlightMatch(self, stack1, card1, stack2, card2): def shallHighlightMatch(self, stack1, card1, stack2, card2):
if card1.rank == ACE or card2.rank == ACE: if card1.rank == ACE or card2.rank == ACE:
return False return False
@ -362,6 +379,7 @@ class GreatWheel(PictureGallery):
# * Zeus # * Zeus
# ************************************************************************ # ************************************************************************
class MountOlympus_Foundation(SS_FoundationStack): class MountOlympus_Foundation(SS_FoundationStack):
def getHelp(self): def getHelp(self):
return 'Build up in suit by twos.' return 'Build up in suit by twos.'
@ -385,12 +403,16 @@ class MountOlympus(Game):
# create stacks # create stacks
x, y = l.XM+l.XS, l.YM x, y = l.XM+l.XS, l.YM
for i in range(8): for i in range(8):
s.foundations.append(MountOlympus_Foundation(x, y, self, s.foundations.append(
MountOlympus_Foundation(
x, y, self,
suit=i/2, base_rank=ACE, dir=2, max_move=0, max_cards=7)) suit=i/2, base_rank=ACE, dir=2, max_move=0, max_cards=7))
x += l.XS x += l.XS
x, y = l.XM+l.XS, l.YM+l.YS x, y = l.XM+l.XS, l.YM+l.YS
for i in range(8): for i in range(8):
s.foundations.append(MountOlympus_Foundation(x, y, self, s.foundations.append(
MountOlympus_Foundation(
x, y, self,
suit=i/2, base_rank=1, dir=2, max_move=0, max_cards=6)) suit=i/2, base_rank=1, dir=2, max_move=0, max_cards=6))
x += l.XS x += l.XS
x, y = l.XM, l.YM+2*l.YS x, y = l.XM, l.YM+2*l.YS
@ -403,24 +425,21 @@ class MountOlympus(Game):
# define stack-groups # define stack-groups
l.defaultStackGroups() l.defaultStackGroups()
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
return self._shuffleHookMoveToTop(cards, return self._shuffleHookMoveToTop(
cards,
lambda c: (c.rank in (ACE, 1), (c.rank, c.suit))) lambda c: (c.rank in (ACE, 1), (c.rank, c.suit)))
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
self.s.talon.dealRow(rows=self.s.foundations) self.s.talon.dealRow(rows=self.s.foundations)
self.s.talon.dealRow() self.s.talon.dealRow()
def fillStack(self, stack): def fillStack(self, stack):
if self.s.talon.cards: if self.s.talon.cards:
if stack in self.s.rows and len(stack.cards) == 0: if stack in self.s.rows and len(stack.cards) == 0:
self.s.talon.dealRow(rows=[stack]) self.s.talon.dealRow(rows=[stack])
def shallHighlightMatch(self, stack1, card1, stack2, card2): def shallHighlightMatch(self, stack1, card1, stack2, card2):
return (card1.suit == card2.suit and return (card1.suit == card2.suit and
(card1.rank + 2 == card2.rank or card2.rank + 2 == card1.rank)) (card1.rank + 2 == card2.rank or card2.rank + 2 == card1.rank))
@ -434,8 +453,10 @@ class Zeus_RowStack(MountOlympus_RowStack):
return cards[0].rank in (QUEEN, KING) return cards[0].rank in (QUEEN, KING)
return True return True
class Zeus(MountOlympus): class Zeus(MountOlympus):
RowStack_Class = Zeus_RowStack RowStack_Class = Zeus_RowStack
def startGame(self): def startGame(self):
self.s.talon.dealRow(rows=self.s.foundations, frames=0) self.s.talon.dealRow(rows=self.s.foundations, frames=0)
self.startDealSample() self.startDealSample()
@ -462,7 +483,8 @@ class RoyalParade_TableauStack(PictureGallery_TableauStack):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if self._canSwapPair(from_stack): if self._canSwapPair(from_stack):
return True return True
return PictureGallery_TableauStack.acceptsCards(self, from_stack, cards) return PictureGallery_TableauStack.acceptsCards(
self, from_stack, cards)
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
if self._canSwapPair(to_stack): if self._canSwapPair(to_stack):
@ -531,7 +553,7 @@ class VirginiaReel(RoyalParade):
bottom_cards.append(c) bottom_cards.append(c)
if len(ranks) == 3: if len(ranks) == 3:
break break
bottom_cards.sort(lambda a, b: cmp(b.rank, a.rank)) bottom_cards = sorted(bottom_cards, key=lambda x: x.rank)[::-1]
return cards+bottom_cards return cards+bottom_cards
def startGame(self): def startGame(self):
@ -546,7 +568,6 @@ class VirginiaReel(RoyalParade):
pass pass
# register the game # register the game
registerGame(GameInfo(7, PictureGallery, "Picture Gallery", registerGame(GameInfo(7, PictureGallery, "Picture Gallery",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED, GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED,
@ -564,5 +585,3 @@ registerGame(GameInfo(546, RoyalParade, "Royal Parade",
rules_filename='virginiareel.html')) rules_filename='virginiareel.html'))
registerGame(GameInfo(547, VirginiaReel, "Virginia Reel", registerGame(GameInfo(547, VirginiaReel, "Virginia Reel",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))

58
pysollib/games/pileon.py
View file

@ -24,23 +24,37 @@
__all__ = [] __all__ = []
# imports # imports
import sys
# PySol imports # PySol imports
from pysollib.mygettext import _, n_ from pysollib.mygettext import _
from pysollib.gamedb import registerGame, GameInfo, GI from pysollib.gamedb import registerGame, GameInfo, GI
from pysollib.util import *
from pysollib.stack import *
from pysollib.game import Game from pysollib.game import Game
from pysollib.layout import Layout from pysollib.layout import Layout
from pysollib.hint import AbstractHint, DefaultHint, CautiousDefaultHint from pysollib.hint import DefaultHint, CautiousDefaultHint
from pysollib.pysoltk import MfxCanvasText from pysollib.pysoltk import MfxCanvasText
from pysollib.util import ACE, ANY_RANK, ANY_SUIT, RANKS
from pysollib.stack import \
AC_RowStack, \
AbstractFoundationStack, \
DealRowTalonStack, \
InitialDealTalonStack, \
RK_RowStack, \
Stack, \
UD_AC_RowStack, \
UD_RK_RowStack, \
WasteStack, \
WasteTalonStack, \
cardsFaceDown, \
isRankSequence, \
ReserveStack
# ************************************************************************ # ************************************************************************
# * PileOn # * PileOn
# ************************************************************************ # ************************************************************************
class PileOn_RowStack(RK_RowStack): class PileOn_RowStack(RK_RowStack):
getBottomImage = Stack._getReserveBottomImage getBottomImage = Stack._getReserveBottomImage
@ -55,7 +69,7 @@ class PileOn_RowStack(RK_RowStack):
class PileOn(Game): class PileOn(Game):
Hint_Class = DefaultHint Hint_Class = DefaultHint
##Hint_Class = CautiousDefaultHint # Hint_Class = CautiousDefaultHint
TWIDTH = 4 TWIDTH = 4
NSTACKS = 15 NSTACKS = 15
PLAYCARDS = 4 PLAYCARDS = 4
@ -82,7 +96,8 @@ class PileOn(Game):
for j in range(twidth): for j in range(twidth):
if i*twidth+j >= self.NSTACKS: if i*twidth+j >= self.NSTACKS:
break break
stack = PileOn_RowStack(x, y, self, dir=0, max_cards=self.PLAYCARDS) stack = PileOn_RowStack(
x, y, self, dir=0, max_cards=self.PLAYCARDS)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0 stack.CARD_XOFFSET, stack.CARD_YOFFSET = l.XOFFSET, 0
s.rows.append(stack) s.rows.append(stack)
x = x + w x = x + w
@ -122,12 +137,12 @@ class SmallPileOn(PileOn):
PLAYCARDS = 4 PLAYCARDS = 4
## class PileOn2Decks(PileOn): # class PileOn2Decks(PileOn):
## TWIDTH = 4 # TWIDTH = 4
## NSTACKS = 15 # NSTACKS = 15
## PLAYCARDS = 8 # PLAYCARDS = 8
## registerGame(GameInfo(341, PileOn2Decks, "PileOn (2 decks)", # registerGame(GameInfo(341, PileOn2Decks, "PileOn (2 decks)",
## GI.GT_2DECK_TYPE | GI.GT_OPEN,, 2, 0)) # GI.GT_2DECK_TYPE | GI.GT_OPEN,, 2, 0))
# ************************************************************************ # ************************************************************************
@ -179,7 +194,6 @@ class Foursome(Game):
self.flipMove(self.s.foundations[0]) self.flipMove(self.s.foundations[0])
self.leaveState(old_state) self.leaveState(old_state)
shallHighlightMatch = Game._shallHighlightMatch_ACW shallHighlightMatch = Game._shallHighlightMatch_ACW
@ -282,7 +296,6 @@ class FourByFour(Game):
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
self.s.talon.dealRow(rows=self.s.foundations) self.s.talon.dealRow(rows=self.s.foundations)
@ -369,6 +382,7 @@ class Footling(FourByFour):
class DoubleFootling(Footling): class DoubleFootling(Footling):
def createGame(self): def createGame(self):
Footling.createGame(self, rows=10, reserves=5, playcards=18) Footling.createGame(self, rows=10, reserves=5, playcards=18)
def startGame(self): def startGame(self):
for i in range(9): for i in range(9):
self.s.talon.dealRow(frames=0) self.s.talon.dealRow(frames=0)
@ -382,18 +396,20 @@ registerGame(GameInfo(41, PileOn, "PileOn",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL, GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("Fifteen Puzzle",))) altnames=("Fifteen Puzzle",)))
registerGame(GameInfo(289, SmallPileOn, "Small PileOn", registerGame(GameInfo(289, SmallPileOn, "Small PileOn",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL, 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), ranks=(0, 5, 6, 7, 8, 9, 10, 11, 12),
rules_filename="pileon.html")) rules_filename="pileon.html"))
registerGame(GameInfo(554, Foursome, "Foursome", registerGame(GameInfo(554, Foursome, "Foursome",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL)) GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(555, Quartets, "Quartets", registerGame(GameInfo(555, Quartets, "Quartets",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL)) GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0,
GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(703, FourByFour, "Four by Four", registerGame(GameInfo(703, FourByFour, "Four by Four",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED)) GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(740, Footling, "Footling", registerGame(GameInfo(740, Footling, "Footling",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL)) GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0,
GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(741, DoubleFootling, "Double Footling", registerGame(GameInfo(741, DoubleFootling, "Double Footling",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0,
GI.SL_MOSTLY_SKILL))

30
pysollib/games/pushpin.py
View file

@ -27,16 +27,23 @@ __all__ = []
# PySol imports # PySol imports
from pysollib.gamedb import registerGame, GameInfo, GI from pysollib.gamedb import registerGame, GameInfo, GI
from pysollib.util import *
from pysollib.stack import *
from pysollib.game import Game from pysollib.game import Game
from pysollib.layout import Layout from pysollib.layout import Layout
from pysollib.hint import AbstractHint, DefaultHint, CautiousDefaultHint from pysollib.hint import AbstractHint
from pysollib.util import ANY_RANK, ANY_SUIT
from pysollib.stack import \
AbstractFoundationStack, \
DealRowTalonStack, \
Stack, \
ReserveStack
# ************************************************************************ # ************************************************************************
# * # *
# ************************************************************************ # ************************************************************************
class PushPin_Hint(AbstractHint): class PushPin_Hint(AbstractHint):
def computeHints(self): def computeHints(self):
@ -58,6 +65,7 @@ class PushPin_Foundation(AbstractFoundationStack):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
return True return True
class PushPin_Talon(DealRowTalonStack): class PushPin_Talon(DealRowTalonStack):
def dealCards(self, sound=False): def dealCards(self, sound=False):
for r in self.game.s.rows: for r in self.game.s.rows:
@ -66,6 +74,7 @@ class PushPin_Talon(DealRowTalonStack):
return self.dealRowAvail(rows=[self.game.s.rows[0]], sound=sound) return self.dealRowAvail(rows=[self.game.s.rows[0]], sound=sound)
getBottomImage = Stack._getNoneBottomImage getBottomImage = Stack._getNoneBottomImage
class PushPin_RowStack(ReserveStack): class PushPin_RowStack(ReserveStack):
def _checkPair(self, ps, ns): def _checkPair(self, ps, ns):
@ -100,10 +109,11 @@ class PushPin_RowStack(ReserveStack):
self.game.fillEmptyStacks() self.game.fillEmptyStacks()
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
if not to_stack is self.game.s.foundations[0]: if to_stack is not self.game.s.foundations[0]:
self._dropPairMove(ncards, to_stack, frames=-1, shadow=shadow) self._dropPairMove(ncards, to_stack, frames=-1, shadow=shadow)
else: else:
ReserveStack.moveMove(self, ncards, to_stack, frames=frames, shadow=shadow) ReserveStack.moveMove(
self, ncards, to_stack, frames=frames, shadow=shadow)
def _dropPairMove(self, n, other_stack, frames=-1, shadow=-1): def _dropPairMove(self, n, other_stack, frames=-1, shadow=-1):
game = self.game game = self.game
@ -283,12 +293,14 @@ class Accordion(PushPin):
# * Accordion (fixed) # * Accordion (fixed)
# ************************************************************************ # ************************************************************************
class Accordion2_RowStack(Accordion_RowStack): class Accordion2_RowStack(Accordion_RowStack):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not Accordion_RowStack.acceptsCards(self, from_stack, cards): if not Accordion_RowStack.acceptsCards(self, from_stack, cards):
return False return False
# accepts only from right stack # accepts only from right stack
return self.id < from_stack.id return self.id < from_stack.id
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
game = self.game game = self.game
old_state = game.enterState(game.S_FILL) old_state = game.enterState(game.S_FILL)
@ -302,8 +314,10 @@ class Accordion2_RowStack(Accordion_RowStack):
game.updateStackMove(game.s.talon, 1 | 16) # for redo game.updateStackMove(game.s.talon, 1 | 16) # for redo
game.leaveState(old_state) game.leaveState(old_state)
class Accordion2(Accordion): class Accordion2(Accordion):
RowStack_Class = Accordion2_RowStack RowStack_Class = Accordion2_RowStack
def isGameWon(self): def isGameWon(self):
return len(self.s.foundations[0].cards) == 51 return len(self.s.foundations[0].cards) == 51
@ -311,9 +325,11 @@ class Accordion2(Accordion):
# * Relaxed Accordion # * Relaxed Accordion
# ************************************************************************ # ************************************************************************
class RelaxedAccordion_RowStack(Accordion2_RowStack): class RelaxedAccordion_RowStack(Accordion2_RowStack):
acceptsCards = Accordion_RowStack.acceptsCards acceptsCards = Accordion_RowStack.acceptsCards
class RelaxedAccordion(Accordion2): class RelaxedAccordion(Accordion2):
RowStack_Class = RelaxedAccordion_RowStack RowStack_Class = RelaxedAccordion_RowStack
@ -322,8 +338,8 @@ registerGame(GameInfo(287, PushPin, "Push Pin",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(288, RoyalMarriage, "Royal Marriage", registerGame(GameInfo(288, RoyalMarriage, "Royal Marriage",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
## registerGame(GameInfo(303, Queens, "Queens", # registerGame(GameInfo(303, Queens, "Queens",
## GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0)) # GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0))
registerGame(GameInfo(656, Accordion, "Bayan", registerGame(GameInfo(656, Accordion, "Bayan",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED)) GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(772, Accordion2, "Accordion", registerGame(GameInfo(772, Accordion2, "Accordion",

81
pysollib/games/pyramid.py
View file

@ -1,6 +1,6 @@
#!/usr/bin/env python #!/usr/bin/env python
# -*- mode: python; coding: utf-8; -*- # -*- mode: python; coding: utf-8; -*-
# ---------------------------------------------------------------------------## # ---------------------------------------------------------------------------
# #
# Copyright (C) 1998-2003 Markus Franz Xaver Johannes Oberhumer # Copyright (C) 1998-2003 Markus Franz Xaver Johannes Oberhumer
# Copyright (C) 2003 Mt. Hood Playing Card Co. # Copyright (C) 2003 Mt. Hood Playing Card Co.
@ -19,22 +19,38 @@
# You should have received a copy of the GNU General Public License # You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>. # along with this program. If not, see <http://www.gnu.org/licenses/>.
# #
# ---------------------------------------------------------------------------## # ---------------------------------------------------------------------------
__all__ = [] __all__ = []
# imports # imports
import sys
# PySol imports # PySol imports
from pysollib.gamedb import registerGame, GameInfo, GI from pysollib.gamedb import registerGame, GameInfo, GI
from pysollib.util import *
from pysollib.stack import *
from pysollib.game import Game from pysollib.game import Game
from pysollib.layout import Layout from pysollib.layout import Layout
from pysollib.hint import AbstractHint, DefaultHint, CautiousDefaultHint from pysollib.hint import DefaultHint
from pysollib.pysoltk import MfxCanvasText from pysollib.pysoltk import MfxCanvasText
from pysollib.util import ANY_RANK, ANY_SUIT, JACK, KING, NO_RANK, QUEEN, \
UNLIMITED_CARDS, UNLIMITED_REDEALS
from pysollib.stack import \
AbstractFoundationStack, \
BasicRowStack, \
DealReserveRedealTalonStack, \
DealRowTalonStack, \
FaceUpWasteTalonStack, \
InitialDealTalonStack, \
OpenStack, \
Stack, \
StackWrapper, \
TalonStack, \
WasteStack, \
WasteTalonStack, \
getNumberOfFreeStacks, \
ReserveStack
# ************************************************************************ # ************************************************************************
# * # *
@ -73,7 +89,8 @@ class Pyramid_StackMethods:
def _dropPairMove(self, n, other_stack, frames=-1, shadow=-1): def _dropPairMove(self, n, other_stack, frames=-1, shadow=-1):
if not self.game.demo: if not self.game.demo:
self.game.playSample("droppair", priority=200) self.game.playSample("droppair", priority=200)
assert n == 1 and self.acceptsCards(other_stack, [other_stack.cards[-1]]) assert n == 1 and self.acceptsCards(
other_stack, [other_stack.cards[-1]])
old_state = self.game.enterState(self.game.S_FILL) old_state = self.game.enterState(self.game.S_FILL)
f = self.game.s.foundations[0] f = self.game.s.foundations[0]
self.game.moveMove(n, self, f, frames=frames, shadow=shadow) self.game.moveMove(n, self, f, frames=frames, shadow=shadow)
@ -84,7 +101,8 @@ class Pyramid_StackMethods:
def moveMove(self, ncards, to_stack, frames=-1, shadow=-1): def moveMove(self, ncards, to_stack, frames=-1, shadow=-1):
if to_stack in self.game.s.foundations: if to_stack in self.game.s.foundations:
self.game.moveMove(ncards, self, to_stack, frames=frames, shadow=shadow) self.game.moveMove(
ncards, self, to_stack, frames=frames, shadow=shadow)
self.fillStack() self.fillStack()
else: else:
self._dropPairMove(ncards, to_stack, frames=-1, shadow=shadow) self._dropPairMove(ncards, to_stack, frames=-1, shadow=shadow)
@ -220,7 +238,6 @@ class Pyramid(Game):
n += 1 n += 1
return rows return rows
def createGame(self, pyramid_len=7, reserves=0, waste=True, texts=True): def createGame(self, pyramid_len=7, reserves=0, waste=True, texts=True):
# create layout # create layout
l, s = Layout(self), self.s l, s = Layout(self), self.s
@ -269,7 +286,6 @@ class Pyramid(Game):
if s.waste: if s.waste:
self.sg.openstacks.append(s.waste) self.sg.openstacks.append(s.waste)
# #
# game overrides # game overrides
# #
@ -364,7 +380,6 @@ class Thirteen(Pyramid):
self.sg.openstacks = s.rows + self.sg.talonstacks self.sg.openstacks = s.rows + self.sg.talonstacks
self.sg.dropstacks = s.rows + self.sg.talonstacks self.sg.dropstacks = s.rows + self.sg.talonstacks
# #
# game overrides # game overrides
# #
@ -426,6 +441,7 @@ class Thirteens(Pyramid):
# * Suit Elevens # * Suit Elevens
# ************************************************************************ # ************************************************************************
class Elevens_RowStack(Giza_Reserve): class Elevens_RowStack(Giza_Reserve):
ACCEPTED_SUM = 9 ACCEPTED_SUM = 9
@ -457,7 +473,7 @@ class Elevens_Reserve(ReserveStack):
if not ReserveStack.acceptsCards(self, from_stack, cards): if not ReserveStack.acceptsCards(self, from_stack, cards):
return False return False
c = cards[0] c = cards[0]
if not c.rank in self.ACCEPTED_CARDS: if c.rank not in self.ACCEPTED_CARDS:
return False return False
for s in self.game.s.reserves: for s in self.game.s.reserves:
if s.cards and s.cards[0].rank == c.rank: if s.cards and s.cards[0].rank == c.rank:
@ -507,12 +523,10 @@ class Elevens(Pyramid):
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
self.s.talon.dealRow() self.s.talon.dealRow()
def fillStack(self, stack): def fillStack(self, stack):
old_state = self.enterState(self.S_FILL) old_state = self.enterState(self.S_FILL)
if stack in self.s.rows: if stack in self.s.rows:
@ -530,7 +544,6 @@ class Elevens(Pyramid):
s.moveMove(1, self.s.foundations[0], frames=4) s.moveMove(1, self.s.foundations[0], frames=4)
self.leaveState(old_state) self.leaveState(old_state)
def shallHighlightMatch(self, stack1, card1, stack2, card2): def shallHighlightMatch(self, stack1, card1, stack2, card2):
# FIXME # FIXME
return False return False
@ -564,6 +577,7 @@ class SuitElevens_RowStack(Elevens_RowStack):
return False return False
return cards[0].suit == self.cards[0].suit return cards[0].suit == self.cards[0].suit
class SuitElevens_Reserve(Elevens_Reserve): class SuitElevens_Reserve(Elevens_Reserve):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not Elevens_Reserve.acceptsCards(self, from_stack, cards): if not Elevens_Reserve.acceptsCards(self, from_stack, cards):
@ -573,9 +587,11 @@ class SuitElevens_Reserve(Elevens_Reserve):
return False return False
return True return True
class SuitElevens(Elevens): class SuitElevens(Elevens):
RowStack_Class = SuitElevens_RowStack RowStack_Class = SuitElevens_RowStack
Reserve_Class = SuitElevens_Reserve Reserve_Class = SuitElevens_Reserve
def createGame(self): def createGame(self):
Elevens.createGame(self, rows=3, cols=5) Elevens.createGame(self, rows=3, cols=5)
@ -586,6 +602,7 @@ class SuitElevens(Elevens):
class Fifteens_RowStack(Elevens_RowStack): class Fifteens_RowStack(Elevens_RowStack):
ACCEPTED_SUM = 13 ACCEPTED_SUM = 13
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not Elevens_RowStack.acceptsCards(self, from_stack, cards): if not Elevens_RowStack.acceptsCards(self, from_stack, cards):
return False return False
@ -768,12 +785,10 @@ class Pharaohs(Pyramid):
# define stack-groups # define stack-groups
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
self.s.talon.dealRow(frames=4) self.s.talon.dealRow(frames=4)
def shallHighlightMatch(self, stack1, card1, stack2, card2): def shallHighlightMatch(self, stack1, card1, stack2, card2):
return (card1.rank + card2.rank == 11 or return (card1.rank + card2.rank == 11 or
card1.rank == card2.rank) card1.rank == card2.rank)
@ -923,6 +938,7 @@ class Apophis(Pharaohs):
# * Cheops # * Cheops
# ************************************************************************ # ************************************************************************
class Cheops_StackMethods(Pyramid_StackMethods): class Cheops_StackMethods(Pyramid_StackMethods):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if self.basicIsBlocked(): if self.basicIsBlocked():
@ -933,14 +949,17 @@ class Cheops_StackMethods(Pyramid_StackMethods):
return (c.face_up and cards[0].face_up and return (c.face_up and cards[0].face_up and
abs(cards[0].rank-c.rank) in (0, 1)) abs(cards[0].rank-c.rank) in (0, 1))
class Cheops_Talon(Cheops_StackMethods, Pyramid_Talon): class Cheops_Talon(Cheops_StackMethods, Pyramid_Talon):
def clickHandler(self, event): def clickHandler(self, event):
return FaceUpWasteTalonStack.clickHandler(self, event) return FaceUpWasteTalonStack.clickHandler(self, event)
class Cheops_Waste(Cheops_StackMethods, Pyramid_Waste): class Cheops_Waste(Cheops_StackMethods, Pyramid_Waste):
def clickHandler(self, event): def clickHandler(self, event):
return WasteStack.clickHandler(self, event) return WasteStack.clickHandler(self, event)
class Cheops_RowStack(Cheops_StackMethods, Pyramid_RowStack): class Cheops_RowStack(Cheops_StackMethods, Pyramid_RowStack):
def clickHandler(self, event): def clickHandler(self, event):
return OpenStack.clickHandler(self, event) return OpenStack.clickHandler(self, event)
@ -1034,7 +1053,7 @@ class Exit(Game):
swap_index = jack_indexes[1] swap_index = jack_indexes[1]
if len(jack_indexes) >= 2: if len(jack_indexes) >= 2:
break break
if not swap_index is None: if swap_index is not None:
i = -1 i = -1
if cards[-1].rank == JACK: # paranoia if cards[-1].rank == JACK: # paranoia
i = -2 i = -2
@ -1050,8 +1069,8 @@ class Exit(Game):
self.s.talon.dealRow(rows=self.s.reserves, frames=4) self.s.talon.dealRow(rows=self.s.reserves, frames=4)
self.s.talon.dealRow(rows=self.s.reserves, frames=4) self.s.talon.dealRow(rows=self.s.reserves, frames=4)
## def getAutoStacks(self, event=None): # def getAutoStacks(self, event=None):
## return ((), (), self.sg.dropstacks) # return ((), (), self.sg.dropstacks)
def shallHighlightMatch(self, stack1, card1, stack2, card2): def shallHighlightMatch(self, stack1, card1, stack2, card2):
return self._checkPair(card1, card2) return self._checkPair(card1, card2)
@ -1115,7 +1134,8 @@ class KingTut(RelaxedPyramid):
s.rows = self._createPyramid(l, x, y, 7) s.rows = self._createPyramid(l, x, y, 7)
x, y = l.XM, self.height-l.YS x, y = l.XM, self.height-l.YS
s.talon = WasteTalonStack(x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3) s.talon = WasteTalonStack(
x, y, self, max_rounds=UNLIMITED_REDEALS, num_deal=3)
l.createText(s.talon, "n") l.createText(s.talon, "n")
x += l.XS x += l.XS
s.waste = Pyramid_Waste(x, y, self, max_accept=1) s.waste = Pyramid_Waste(x, y, self, max_accept=1)
@ -1221,7 +1241,6 @@ class UpAndDown(Pyramid):
self.sg.dropstacks.append(s.talon) self.sg.dropstacks.append(s.talon)
self.sg.openstacks.append(s.waste) self.sg.openstacks.append(s.waste)
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
self.s.talon.dealRow(frames=4) self.s.talon.dealRow(frames=4)
@ -1260,9 +1279,11 @@ class Hurricane_StackMethods(Pyramid_StackMethods):
frames=frames, shadow=shadow) frames=frames, shadow=shadow)
self.fillStack() self.fillStack()
class Hurricane_RowStack(Hurricane_StackMethods, BasicRowStack): class Hurricane_RowStack(Hurricane_StackMethods, BasicRowStack):
pass pass
class Hurricane_Reserve(Hurricane_StackMethods, OpenStack): class Hurricane_Reserve(Hurricane_StackMethods, OpenStack):
pass pass
@ -1310,7 +1331,6 @@ class Hurricane(Pyramid):
# define stack-groups # define stack-groups
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
for i in range(2): for i in range(2):
self.s.talon.dealRow(rows=self.s.reserves, frames=0) self.s.talon.dealRow(rows=self.s.reserves, frames=0)
@ -1318,7 +1338,6 @@ class Hurricane(Pyramid):
self.s.talon.dealRow(rows=self.s.reserves) self.s.talon.dealRow(rows=self.s.reserves)
self.s.talon.dealRow() self.s.talon.dealRow()
def fillStack(self, stack): def fillStack(self, stack):
if stack in self.s.rows and not stack.cards and self.s.talon.cards: if stack in self.s.rows and not stack.cards and self.s.talon.cards:
old_state = self.enterState(self.S_FILL) old_state = self.enterState(self.S_FILL)
@ -1327,15 +1346,15 @@ class Hurricane(Pyramid):
self.leaveState(old_state) self.leaveState(old_state)
# register the game # register the game
registerGame(GameInfo(38, Pyramid, "Pyramid", registerGame(GameInfo(38, Pyramid, "Pyramid",
GI.GT_PAIRING_TYPE, 1, 2, GI.SL_MOSTLY_LUCK)) GI.GT_PAIRING_TYPE, 1, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(193, RelaxedPyramid, "Relaxed Pyramid", registerGame(GameInfo(193, RelaxedPyramid, "Relaxed Pyramid",
GI.GT_PAIRING_TYPE | GI.GT_RELAXED, 1, 2, GI.SL_MOSTLY_LUCK, GI.GT_PAIRING_TYPE | GI.GT_RELAXED, 1, 2,
GI.SL_MOSTLY_LUCK,
altnames=(" Pyramid's Stones",))) altnames=(" Pyramid's Stones",)))
##registerGame(GameInfo(44, Thirteen, "Thirteen", # registerGame(GameInfo(44, Thirteen, "Thirteen",
## GI.GT_PAIRING_TYPE, 1, 0)) # GI.GT_PAIRING_TYPE, 1, 0))
registerGame(GameInfo(592, Giza, "Giza", registerGame(GameInfo(592, Giza, "Giza",
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED)) GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(593, Thirteens, "Thirteens", registerGame(GameInfo(593, Thirteens, "Thirteens",
@ -1362,7 +1381,8 @@ registerGame(GameInfo(659, Cheops, "Cheops",
registerGame(GameInfo(674, Exit, "Exit", registerGame(GameInfo(674, Exit, "Exit",
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_SKILL)) GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(677, TwoPyramids, "Two Pyramids", registerGame(GameInfo(677, TwoPyramids, "Two Pyramids",
GI.GT_PAIRING_TYPE | GI.GT_ORIGINAL, 2, 2, GI.SL_MOSTLY_LUCK)) GI.GT_PAIRING_TYPE | GI.GT_ORIGINAL, 2, 2,
GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(681, KingTut, "King Tut", registerGame(GameInfo(681, KingTut, "King Tut",
GI.GT_PAIRING_TYPE, 1, -1, GI.SL_MOSTLY_LUCK)) GI.GT_PAIRING_TYPE, 1, -1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(699, DoublePyramid, "Double Pyramid", registerGame(GameInfo(699, DoublePyramid, "Double Pyramid",
@ -1370,6 +1390,7 @@ registerGame(GameInfo(699, DoublePyramid, "Double Pyramid",
registerGame(GameInfo(700, Triangle, "Triangle", registerGame(GameInfo(700, Triangle, "Triangle",
GI.GT_PAIRING_TYPE, 1, 2, GI.SL_MOSTLY_LUCK)) GI.GT_PAIRING_TYPE, 1, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(701, UpAndDown, "Up and Down", registerGame(GameInfo(701, UpAndDown, "Up and Down",
GI.GT_PAIRING_TYPE | GI.GT_ORIGINAL, 2, 2, GI.SL_MOSTLY_LUCK)) GI.GT_PAIRING_TYPE | GI.GT_ORIGINAL, 2, 2,
GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(735, Hurricane, "Hurricane", registerGame(GameInfo(735, Hurricane, "Hurricane",
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))

2
tests/style/py-flake8.t
View file

@ -10,7 +10,7 @@ use String::ShellQuote qw/ shell_quote /;
# my $cmd = shell_quote( 'flake8', '.' ); # my $cmd = shell_quote( 'flake8', '.' );
my $cmd = shell_quote( 'flake8', my $cmd = shell_quote( 'flake8',
grep { not($_ eq './pysollib/pysoltk.py' or $_ eq './pysollib/tile/ttk.py') } glob('./pysollib/*.py ./pysollib/[cmpuw]*/*.py ./pysollib/tile/*.py ./pysollib/ui/tktile/*.py ./pysollib/games/[a-oy-z]*.py') ); grep { not($_ eq './pysollib/pysoltk.py' or $_ eq './pysollib/tile/ttk.py') } glob('./pysollib/*.py ./pysollib/[cmpuw]*/*.py ./pysollib/tile/*.py ./pysollib/ui/tktile/*.py ./pysollib/games/[a-py-z]*.py') );
# TEST # TEST
eq_or_diff( scalar(`$cmd`), '', "flake8 is happy with the code." ); eq_or_diff( scalar(`$cmd`), '', "flake8 is happy with the code." );