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

Browse source
This commit is contained in:
Shlomi Fish 2017-04-17 23:23:04 +03:00
parent b44d11c281
commit e76ddb8a13
6 changed files with 210 additions and 123 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

38
pysollib/games/glenwood.py
View file

@ -24,29 +24,39 @@
__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 CautiousDefaultHint
from pysollib.pysoltk import MfxCanvasText from pysollib.pysoltk import MfxCanvasText
from canfield import Canfield_Hint from canfield import Canfield_Hint
from pysollib.util import ANY_RANK, RANKS
from pysollib.stack import \
AC_RowStack, \
AbstractFoundationStack, \
OpenStack, \
RedealTalonStack, \
SS_RowStack, \
WasteStack, \
WasteTalonStack
# ************************************************************************ # ************************************************************************
# * Glenwood # * Glenwood
# ************************************************************************ # ************************************************************************
class Glenwood_Talon(WasteTalonStack): class Glenwood_Talon(WasteTalonStack):
def canDealCards(self): def canDealCards(self):
if self.game.base_rank is None: if self.game.base_rank is None:
return False return False
return WasteTalonStack.canDealCards(self) return WasteTalonStack.canDealCards(self)
class Glenwood_Foundation(AbstractFoundationStack): class Glenwood_Foundation(AbstractFoundationStack):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not AbstractFoundationStack.acceptsCards(self, from_stack, cards): if not AbstractFoundationStack.acceptsCards(self, from_stack, cards):
@ -56,7 +66,9 @@ class Glenwood_Foundation(AbstractFoundationStack):
if not self.cards: if not self.cards:
return cards[-1].rank == self.game.base_rank return cards[-1].rank == self.game.base_rank
# check the rank # check the rank
return (self.cards[-1].rank + self.cap.dir) % self.cap.mod == cards[0].rank return (self.cards[-1].rank + self.cap.dir) % \
self.cap.mod == cards[0].rank
class Glenwood_RowStack(AC_RowStack): class Glenwood_RowStack(AC_RowStack):
def canMoveCards(self, cards): def canMoveCards(self, cards):
@ -76,7 +88,8 @@ class Glenwood_RowStack(AC_RowStack):
if stack.cards: if stack.cards:
return False return False
return True return True
if from_stack in self.game.s.rows and len(cards) != len(from_stack.cards): if from_stack in self.game.s.rows and \
len(cards) != len(from_stack.cards):
return False return False
return True return True
@ -86,9 +99,9 @@ class Glenwood_ReserveStack(OpenStack):
OpenStack.moveMove(self, ncards, to_stack, frames, shadow) OpenStack.moveMove(self, ncards, to_stack, frames, shadow)
if self.game.base_rank is None and to_stack in self.game.s.foundations: if self.game.base_rank is None and to_stack in self.game.s.foundations:
old_state = self.game.enterState(self.game.S_FILL) old_state = self.game.enterState(self.game.S_FILL)
self.game.saveStateMove(2|16) # for undo self.game.saveStateMove(2 | 16) # for undo
self.game.base_rank = to_stack.cards[-1].rank self.game.base_rank = to_stack.cards[-1].rank
self.game.saveStateMove(1|16) # for redo self.game.saveStateMove(1 | 16) # for redo
self.game.leaveState(old_state) self.game.leaveState(old_state)
@ -233,9 +246,9 @@ class DoubleFives_RowStack(SS_RowStack):
SS_RowStack.moveMove(self, ncards, to_stack, frames, shadow) SS_RowStack.moveMove(self, ncards, to_stack, frames, shadow)
if self.game.base_rank is None and to_stack in self.game.s.foundations: if self.game.base_rank is None and to_stack in self.game.s.foundations:
old_state = self.game.enterState(self.game.S_FILL) old_state = self.game.enterState(self.game.S_FILL)
self.game.saveStateMove(2|16) # for undo self.game.saveStateMove(2 | 16) # for undo
self.game.base_rank = to_stack.cards[-1].rank self.game.base_rank = to_stack.cards[-1].rank
self.game.saveStateMove(1|16) # for redo self.game.saveStateMove(1 | 16) # for redo
self.game.leaveState(old_state) self.game.leaveState(old_state)
@ -250,6 +263,7 @@ class DoubleFives_WasteStack(WasteStack):
class DoubleFives_Stock(WasteStack): class DoubleFives_Stock(WasteStack):
def canFlipCard(self): def canFlipCard(self):
return False return False
def updateText(self): def updateText(self):
if self.cards: if self.cards:
WasteStack.updateText(self) WasteStack.updateText(self)
@ -330,11 +344,9 @@ class DoubleFives(Glenwood):
shallHighlightMatch = Game._shallHighlightMatch_SSW shallHighlightMatch = Game._shallHighlightMatch_SSW
# register the game # register the game
registerGame(GameInfo(282, Glenwood, "Dutchess", registerGame(GameInfo(282, Glenwood, "Dutchess",
GI.GT_CANFIELD, 1, 1, GI.SL_BALANCED, GI.GT_CANFIELD, 1, 1, GI.SL_BALANCED,
altnames=("Duchess", "Glenwood",) )) altnames=("Duchess", "Glenwood",)))
registerGame(GameInfo(587, DoubleFives, "Double Fives", registerGame(GameInfo(587, DoubleFives, "Double Fives",
GI.GT_2DECK_TYPE, 2, 1, GI.SL_BALANCED)) GI.GT_2DECK_TYPE, 2, 1, GI.SL_BALANCED))

100
pysollib/games/golf.py
View file

@ -24,24 +24,46 @@
__all__ = [] __all__ = []
# imports # imports
import sys, types
# 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.mfxutil import kwdefault from pysollib.mfxutil import kwdefault
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, DefaultHint, CautiousDefaultHint
from pysollib.hint import BlackHoleSolverWrapper from pysollib.hint import BlackHoleSolverWrapper
from pysollib.pysoltk import MfxCanvasText from pysollib.pysoltk import MfxCanvasText
from pileon import FourByFour_Hint
from pysollib.util import ACE, ANY_RANK, ANY_SUIT, KING, NO_RANK, RANKS, \
SUITS, \
UNLIMITED_REDEALS
from pysollib.stack import \
AbstractFoundationStack, \
BasicRowStack, \
DealRowTalonStack, \
InitialDealTalonStack, \
OpenStack, \
RK_FoundationStack, \
RK_RowStack, \
ReserveStack, \
SS_FoundationStack, \
SS_RowStack, \
Stack, \
TalonStack, \
UD_RK_RowStack, \
WasteStack, \
WasteTalonStack, \
isSameSuitSequence, \
StackWrapper
# ************************************************************************ # ************************************************************************
# * # *
# ************************************************************************ # ************************************************************************
class Golf_Hint(AbstractHint): class Golf_Hint(AbstractHint):
# FIXME: this is very simple # FIXME: this is very simple
@ -107,6 +129,7 @@ class Golf_Waste(WasteStack):
class Golf_RowStack(BasicRowStack): class Golf_RowStack(BasicRowStack):
def clickHandler(self, event): def clickHandler(self, event):
return self.doubleclickHandler(event) return self.doubleclickHandler(event)
def getHelp(self): def getHelp(self):
return _('Tableau. No building.') return _('Tableau. No building.')
@ -268,6 +291,7 @@ class Elevator(RelaxedGolf):
self.s.talon.dealRow(rows=self.s.rows[21:]) self.s.talon.dealRow(rows=self.s.rows[21:])
self.s.talon.dealCards() # deal first card to WasteStack self.s.talon.dealCards() # deal first card to WasteStack
class Escalator(Elevator): class Escalator(Elevator):
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
@ -286,8 +310,10 @@ class BlackHole_Foundation(AbstractFoundationStack):
# check the rank # check the rank
if self.cards: if self.cards:
r1, r2 = self.cards[-1].rank, cards[0].rank r1, r2 = self.cards[-1].rank, cards[0].rank
return (r1 + 1) % self.cap.mod == r2 or (r2 + 1) % self.cap.mod == r1 return (r1 + 1) % self.cap.mod == r2 or \
(r2 + 1) % self.cap.mod == r1
return True return True
def getHelp(self): def getHelp(self):
return _('Foundation. Build up or down regardless of suit.') return _('Foundation. Build up or down regardless of suit.')
@ -295,12 +321,14 @@ class BlackHole_Foundation(AbstractFoundationStack):
class BlackHole_RowStack(ReserveStack): class BlackHole_RowStack(ReserveStack):
def clickHandler(self, event): def clickHandler(self, event):
return self.doubleclickHandler(event) return self.doubleclickHandler(event)
def getHelp(self): def getHelp(self):
return _('Tableau. No building.') return _('Tableau. No building.')
class BlackHole(Game): class BlackHole(Game):
RowStack_Class = StackWrapper(BlackHole_RowStack, max_accept=0, max_cards=3) RowStack_Class = StackWrapper(
BlackHole_RowStack, max_accept=0, max_cards=3)
Hint_Class = Golf_Hint Hint_Class = Golf_Hint
Solver_Class = BlackHoleSolverWrapper(preset='black_hole') Solver_Class = BlackHoleSolverWrapper(preset='black_hole')
@ -349,7 +377,8 @@ class BlackHole(Game):
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
# move Ace to bottom of the Talon (i.e. last cards to be dealt) # move Ace to bottom of the Talon (i.e. last cards to be dealt)
return self._shuffleHookMoveToBottom(cards, lambda c: (c.id == 13, c.suit), 1) return self._shuffleHookMoveToBottom(
cards, lambda c: (c.id == 13, c.suit), 1)
def startGame(self): def startGame(self):
for i in range(2): for i in range(2):
@ -367,7 +396,6 @@ class BlackHole(Game):
return ((), self.sg.dropstacks, self.sg.dropstacks) return ((), self.sg.dropstacks, self.sg.dropstacks)
# ************************************************************************ # ************************************************************************
# * Four Leaf Clovers # * Four Leaf Clovers
# ************************************************************************ # ************************************************************************
@ -381,6 +409,7 @@ class FourLeafClovers_Foundation(AbstractFoundationStack):
r1, r2 = self.cards[-1].rank, cards[0].rank r1, r2 = self.cards[-1].rank, cards[0].rank
return (r1 + 1) % self.cap.mod == r2 return (r1 + 1) % self.cap.mod == r2
return True return True
def getHelp(self): def getHelp(self):
return _('Foundation. Build up regardless of suit.') return _('Foundation. Build up regardless of suit.')
@ -405,11 +434,13 @@ class FourLeafClovers(Game):
y = l.YM y = l.YM
for i in range(7): for i in range(7):
x = l.XM + i*l.XS x = l.XM + i*l.XS
s.rows.append(UD_RK_RowStack(x, y, self, mod=13, base_rank=NO_RANK)) s.rows.append(
UD_RK_RowStack(x, y, self, mod=13, base_rank=NO_RANK))
y = l.YM+h y = l.YM+h
for i in range(6): for i in range(6):
x = l.XM + i*l.XS x = l.XM + i*l.XS
s.rows.append(UD_RK_RowStack(x, y, self, mod=13, base_rank=NO_RANK)) s.rows.append(
UD_RK_RowStack(x, y, self, mod=13, base_rank=NO_RANK))
stack = FourLeafClovers_Foundation(l.XM+6*l.XS, self.height-l.YS, self, stack = FourLeafClovers_Foundation(l.XM+6*l.XS, self.height-l.YS, self,
suit=ANY_SUIT, dir=0, mod=13, suit=ANY_SUIT, dir=0, mod=13,
max_move=0, max_cards=52) max_move=0, max_cards=52)
@ -437,6 +468,7 @@ class FourLeafClovers(Game):
class AllInARow(BlackHole): class AllInARow(BlackHole):
Solver_Class = BlackHoleSolverWrapper(preset='all_in_a_row') Solver_Class = BlackHoleSolverWrapper(preset='all_in_a_row')
def createGame(self): def createGame(self):
# create layout # create layout
l, s = Layout(self), self.s l, s = Layout(self), self.s
@ -458,7 +490,9 @@ class AllInARow(BlackHole):
r.CARD_XOFFSET, r.CARD_YOFFSET = 0, l.YOFFSET r.CARD_XOFFSET, r.CARD_YOFFSET = 0, l.YOFFSET
x, y = l.XM, self.height-l.YS x, y = l.XM, self.height-l.YS
stack = BlackHole_Foundation(x, y, self, ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=52, base_rank=ANY_RANK) stack = BlackHole_Foundation(
x, y, self, ANY_SUIT, dir=0, mod=13, max_move=0, max_cards=52,
base_rank=ANY_RANK)
s.foundations.append(stack) s.foundations.append(stack)
stack.CARD_XOFFSET, stack.CARD_YOFFSET = (self.width-l.XS)/51, 0 stack.CARD_XOFFSET, stack.CARD_YOFFSET = (self.width-l.XS)/51, 0
l.createText(stack, 'n') l.createText(stack, 'n')
@ -468,7 +502,6 @@ class AllInARow(BlackHole):
# define stack-groups # define stack-groups
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
for i in range(3): for i in range(3):
self.s.talon.dealRow(frames=0) self.s.talon.dealRow(frames=0)
@ -526,6 +559,7 @@ class Wasatch(Robert):
DIAMOND = 3 DIAMOND = 3
class DiamondMine_RowStack(RK_RowStack): class DiamondMine_RowStack(RK_RowStack):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not RK_RowStack.acceptsCards(self, from_stack, cards): if not RK_RowStack.acceptsCards(self, from_stack, cards):
@ -735,7 +769,6 @@ class Vague(Game):
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
self.startDealSample() self.startDealSample()
self.s.talon.dealRow() self.s.talon.dealRow()
@ -799,8 +832,8 @@ class DevilsSolitaire(Game):
self.setSize(l.XM+9*l.XS, l.YM+3*l.YS+7*l.YOFFSET+2*l.TEXT_HEIGHT) self.setSize(l.XM+9*l.XS, l.YM+3*l.YS+7*l.YOFFSET+2*l.TEXT_HEIGHT)
x, y = l.XM+4*l.XS, l.YM x, y = l.XM+4*l.XS, l.YM
stack = DevilsSolitaire_Foundation(x, y, self, stack = DevilsSolitaire_Foundation(
suit=ANY_SUIT, base_rank=ANY_RANK, mod=13) x, y, self, suit=ANY_SUIT, base_rank=ANY_RANK, mod=13)
tx, ty, ta, tf = l.getTextAttr(stack, 'nw') tx, ty, ta, tf = l.getTextAttr(stack, 'nw')
font = self.app.getFont('canvas_default') font = self.app.getFont('canvas_default')
stack.texts.misc = MfxCanvasText(self.canvas, tx, ty, stack.texts.misc = MfxCanvasText(self.canvas, tx, ty,
@ -808,9 +841,10 @@ class DevilsSolitaire(Game):
s.foundations.append(stack) s.foundations.append(stack)
x, y = self.width-l.XS, l.YM x, y = self.width-l.XS, l.YM
stack = AbstractFoundationStack(x, y, self, stack = AbstractFoundationStack(
suit=ANY_SUIT, max_move=0, max_cards=104, x, y, self,
max_accept=0, base_rank=ANY_RANK) suit=ANY_SUIT, max_move=0, max_cards=104,
max_accept=0, base_rank=ANY_RANK)
l.createText(stack, 'nw') l.createText(stack, 'nw')
s.foundations.append(stack) s.foundations.append(stack)
@ -838,7 +872,6 @@ class DevilsSolitaire(Game):
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self): def startGame(self):
for i in range(8): for i in range(8):
self.s.talon.dealRow(rows=self.s.reserves, frames=0) self.s.talon.dealRow(rows=self.s.reserves, frames=0)
@ -898,20 +931,20 @@ class FirTree_GameMethods:
rows = [] rows = []
# create stacks # create stacks
for i in range(11): for i in range(11):
x = x0 + ((i+1)%2) * l.XS / 2 x = x0 + ((i+1) % 2) * l.XS / 2
y = y0 + i * l.YS / 4 y = y0 + i * l.YS / 4
for j in range((i%2) + 1): for j in range((i % 2) + 1):
rows.append(ThreeFirTrees_RowStack(x, y, self)) rows.append(ThreeFirTrees_RowStack(x, y, self))
x += l.XS x += l.XS
# compute blocking # compute blocking
n = 0 n = 0
for i in range(10): for i in range(10):
if i%2: if i % 2:
rows[n].blockmap = [rows[n+2]] rows[n].blockmap = [rows[n+2]]
rows[n+1].blockmap = [rows[n+2]] rows[n+1].blockmap = [rows[n+2]]
n += 2 n += 2
else: else:
rows[n].blockmap = [rows[n+1],rows[n+2]] rows[n].blockmap = [rows[n+1], rows[n+2]]
n += 1 n += 1
return rows return rows
@ -1024,10 +1057,9 @@ class NapoleonLeavesMoscow(NapoleonTakesMoscow):
# * Flake (2 decks) # * Flake (2 decks)
# ************************************************************************ # ************************************************************************
from pileon import FourByFour_Hint
class Flake(Game): class Flake(Game):
Hint_Class = FourByFour_Hint #CautiousDefaultHint Hint_Class = FourByFour_Hint # CautiousDefaultHint
def createGame(self, rows=6, playcards=18): def createGame(self, rows=6, playcards=18):
# create layout # create layout
@ -1068,6 +1100,7 @@ class Flake(Game):
class Flake2Decks(Flake): class Flake2Decks(Flake):
def createGame(self): def createGame(self):
Flake.createGame(self, rows=8, playcards=22) Flake.createGame(self, rows=8, playcards=22)
def startGame(self): def startGame(self):
for i in range(12): for i in range(12):
self.s.talon.dealRow(frames=0) self.s.talon.dealRow(frames=0)
@ -1125,7 +1158,6 @@ class Beacon(Game):
shallHighlightMatch = Game._shallHighlightMatch_RKW shallHighlightMatch = Game._shallHighlightMatch_RKW
# register the game # register the game
registerGame(GameInfo(36, Golf, "Golf", registerGame(GameInfo(36, Golf, "Golf",
GI.GT_GOLF, 1, 0, GI.SL_BALANCED)) GI.GT_GOLF, 1, 0, GI.SL_BALANCED))
@ -1133,10 +1165,10 @@ registerGame(GameInfo(259, DeadKingGolf, "Dead King Golf",
GI.GT_GOLF, 1, 0, GI.SL_BALANCED)) GI.GT_GOLF, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(260, RelaxedGolf, "Relaxed Golf", registerGame(GameInfo(260, RelaxedGolf, "Relaxed Golf",
GI.GT_GOLF | GI.GT_RELAXED, 1, 0, GI.SL_BALANCED, GI.GT_GOLF | GI.GT_RELAXED, 1, 0, GI.SL_BALANCED,
altnames=("Putt Putt",) )) altnames=("Putt Putt",)))
registerGame(GameInfo(40, Elevator, "Elevator", registerGame(GameInfo(40, Elevator, "Elevator",
GI.GT_GOLF, 1, 0, GI.SL_BALANCED, GI.GT_GOLF, 1, 0, GI.SL_BALANCED,
altnames=("Egyptian Solitaire", "Pyramid Golf") )) altnames=("Egyptian Solitaire", "Pyramid Golf")))
registerGame(GameInfo(98, BlackHole, "Black Hole", registerGame(GameInfo(98, BlackHole, "Black Hole",
GI.GT_GOLF | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GOLF | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(267, FourLeafClovers, "Four Leaf Clovers", registerGame(GameInfo(267, FourLeafClovers, "Four Leaf Clovers",
@ -1154,12 +1186,13 @@ registerGame(GameInfo(661, Dolphin, "Dolphin",
registerGame(GameInfo(662, DoubleDolphin, "Double Dolphin", registerGame(GameInfo(662, DoubleDolphin, "Double Dolphin",
GI.GT_GOLF | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GOLF | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(709, Waterfall, "Waterfall", registerGame(GameInfo(709, Waterfall, "Waterfall",
GI.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0,
GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(720, Vague, "Vague", registerGame(GameInfo(720, Vague, "Vague",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK)) GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(723, DevilsSolitaire, "Devil's Solitaire", registerGame(GameInfo(723, DevilsSolitaire, "Devil's Solitaire",
GI.GT_2DECK_TYPE, 2, 2, GI.SL_BALANCED, GI.GT_2DECK_TYPE, 2, 2, GI.SL_BALANCED,
altnames=('Banner',) )) altnames=('Banner',)))
registerGame(GameInfo(728, ThirtyTwoCards, "Thirty Two Cards", registerGame(GameInfo(728, ThirtyTwoCards, "Thirty Two Cards",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_LUCK)) GI.GT_2DECK_TYPE, 2, 0, GI.SL_LUCK))
registerGame(GameInfo(731, ThreeFirTrees, "Three Fir-trees", registerGame(GameInfo(731, ThreeFirTrees, "Three Fir-trees",
@ -1175,9 +1208,10 @@ registerGame(GameInfo(750, Flake2Decks, "Flake (2 decks)",
GI.GT_GOLF | GI.GT_OPEN | GI.GT_ORIGINAL, GI.GT_GOLF | GI.GT_OPEN | GI.GT_ORIGINAL,
2, 0, GI.SL_MOSTLY_SKILL)) 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(763, Wasatch, "Wasatch", registerGame(GameInfo(763, Wasatch, "Wasatch",
GI.GT_1DECK_TYPE, 1, UNLIMITED_REDEALS, GI.SL_MOSTLY_LUCK)) GI.GT_1DECK_TYPE, 1, UNLIMITED_REDEALS,
GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(764, Beacon, "Beacon", registerGame(GameInfo(764, Beacon, "Beacon",
GI.GT_1DECK_TYPE | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL)) GI.GT_1DECK_TYPE | GI.GT_ORIGINAL, 1, 0,
GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(768, RelaxedThreeFirTrees, "Relaxed Three Fir-trees", registerGame(GameInfo(768, RelaxedThreeFirTrees, "Relaxed Three Fir-trees",
GI.GT_GOLF, 2, 0, GI.SL_BALANCED)) GI.GT_GOLF, 2, 0, GI.SL_BALANCED))

25
pysollib/games/grandduchess.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.mfxutil import kwdefault
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 \
ArbitraryStack, \
BasicRowStack, \
RedealTalonStack, \
SS_FoundationStack
# ************************************************************************ # ************************************************************************
# * Grand Duchess # * Grand Duchess
# ************************************************************************ # ************************************************************************
class GrandDuchess_Talon(RedealTalonStack): class GrandDuchess_Talon(RedealTalonStack):
def canDealCards(self): def canDealCards(self):
@ -117,7 +120,6 @@ class GrandDuchess(Game):
# define stack-groups # define stack-groups
l.defaultStackGroups() l.defaultStackGroups()
# #
# game overrides # game overrides
# #
@ -131,7 +133,6 @@ class GrandDuchess(Game):
def redealCards(self): def redealCards(self):
pass pass
def getAutoStacks(self, event=None): def getAutoStacks(self, event=None):
return ((), (), self.sg.dropstacks) return ((), (), self.sg.dropstacks)
@ -144,8 +145,10 @@ class Parisienne(GrandDuchess):
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
# move one Ace and one King of each suit to top of the Talon # move one Ace and one King of each suit to top of the Talon
# (i.e. first cards to be dealt) # (i.e. first cards to be dealt)
return self._shuffleHookMoveToTop(cards, return self._shuffleHookMoveToTop(
lambda c: (c.rank in (ACE, KING) and c.deck == 0, (c.rank, c.suit))) cards,
lambda c: (c.rank in (ACE, KING) and c.deck == 0,
(c.rank, c.suit)))
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)
@ -157,13 +160,11 @@ class GrandDuchessPlus(GrandDuchess):
GrandDuchess.createGame(self, rows=6) GrandDuchess.createGame(self, rows=6)
registerGame(GameInfo(557, GrandDuchess, "Grand Duchess", registerGame(GameInfo(557, GrandDuchess, "Grand Duchess",
GI.GT_2DECK_TYPE, 2, 3)) GI.GT_2DECK_TYPE, 2, 3))
registerGame(GameInfo(617, Parisienne, "Parisienne", registerGame(GameInfo(617, Parisienne, "Parisienne",
GI.GT_2DECK_TYPE, 2, 3, GI.GT_2DECK_TYPE, 2, 3,
rules_filename='grandduchess.html', rules_filename='grandduchess.html',
altnames=('La Parisienne', 'Parisian') )) altnames=('La Parisienne', 'Parisian')))
registerGame(GameInfo(618, GrandDuchessPlus, "Grand Duchess +", registerGame(GameInfo(618, GrandDuchessPlus, "Grand Duchess +",
GI.GT_2DECK_TYPE, 2, 3)) GI.GT_2DECK_TYPE, 2, 3))

76
pysollib/games/grandfathersclock.py
View file

@ -24,20 +24,33 @@
__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, CautiousDefaultHint
# ************************************************************************ # ************************************************************************
# * # *
# ************************************************************************ # ************************************************************************
from pysollib.util import ACE, ANY_SUIT, JACK, KING, QUEEN
from pysollib.stack import \
AC_FoundationStack, \
BasicRowStack, \
DealRowTalonStack, \
InitialDealTalonStack, \
InvisibleStack, \
RK_RowStack, \
SC_RowStack, \
SS_FoundationStack, \
SS_RowStack, \
WasteStack, \
WasteTalonStack
class GrandfathersClock_Hint(CautiousDefaultHint): class GrandfathersClock_Hint(CautiousDefaultHint):
# FIXME: demo is not too clever in this game # FIXME: demo is not too clever in this game
@ -70,24 +83,26 @@ class GrandfathersClock(Game):
for i in range(2): for i in range(2):
x, y = l.XM, l.YM + i*dh x, y = l.XM, l.YM + i*dh
for j in range(4): for j in range(4):
s.rows.append(RK_RowStack(x, y, self, max_move=1, max_accept=1)) s.rows.append(
RK_RowStack(x, y, self, max_move=1, max_accept=1))
x = x + l.XS x = x + l.XS
y = l.YM + dh - l.CH / 2 y = l.YM + dh - l.CH / 2
self.setRegion(s.rows[:4], (-999, -999, x - l.XM / 2, y)) self.setRegion(s.rows[:4], (-999, -999, x - l.XM / 2, y))
self.setRegion(s.rows[4:], (-999, y, x - l.XM / 2, 999999)) self.setRegion(s.rows[4:], (-999, y, x - l.XM / 2, 999999))
d = [ (0,0), (1,0.15), (2,0.5), (2.5,1.5), (2,2.5), (1,2.85) ] d = [(0, 0), (1, 0.15), (2, 0.5), (2.5, 1.5), (2, 2.5), (1, 2.85)]
for i in range(len(d)): for i in range(len(d)):
d.append( (0 - d[i][0], 3 - d[i][1]) ) d.append((0 - d[i][0], 3 - d[i][1]))
x0, y0 = l.XM, l.YM + dh - l.CH x0, y0 = l.XM, l.YM + dh - l.CH
for i in range(12): for i in range(12):
j = (i + 5) % 12 j = (i + 5) % 12
x = int(round(x0 + ( 6.5+d[j][0]) * l.XS)) x = int(round(x0 + (6.5+d[j][0]) * l.XS))
y = int(round(y0 + (-1.5+d[j][1]) * l.YS)) y = int(round(y0 + (-1.5+d[j][1]) * l.YS))
suit = (1, 2, 0, 3) [i % 4] suit = (1, 2, 0, 3)[i % 4]
s.foundations.append(SS_FoundationStack(x, y, self, suit, s.foundations.append(SS_FoundationStack(x, y, self, suit,
base_rank=i+1, mod=13, base_rank=i+1, mod=13,
max_move=0)) max_move=0))
s.talon = InitialDealTalonStack(self.width-l.XS, self.height-l.YS, self) s.talon = InitialDealTalonStack(
self.width-l.XS, self.height-l.YS, self)
# define stack-groups # define stack-groups
self.sg.openstacks = s.foundations + s.rows self.sg.openstacks = s.foundations + s.rows
@ -107,7 +122,7 @@ class GrandfathersClock(Game):
clocks.append(c) clocks.append(c)
cards.remove(c) cards.remove(c)
# sort clocks reverse by rank # sort clocks reverse by rank
clocks.sort(lambda a, b: cmp(b.rank, a.rank)) clocks.sort(key=lambda x: x.rank)
return clocks + cards return clocks + cards
def startGame(self): def startGame(self):
@ -155,8 +170,10 @@ class Dial(Game):
): ):
x = int(x0 + xx*l.XS) x = int(x0 + xx*l.XS)
y = int(y0 + yy*l.YS) y = int(y0 + yy*l.YS)
s.foundations.append(AC_FoundationStack(x, y, self, suit=ANY_SUIT, s.foundations.append(
dir=0, max_cards=4, base_rank=rank, max_move=0)) AC_FoundationStack(
x, y, self, suit=ANY_SUIT,
dir=0, max_cards=4, base_rank=rank, max_move=0))
rank += 1 rank += 1
x, y = l.XM, l.YM x, y = l.XM, l.YM
@ -314,31 +331,29 @@ class Hemispheres(Game):
l.defaultStackGroups() l.defaultStackGroups()
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
founds_cards = [] # foundations founds_cards = [] # foundations
rows_cards = [] # rows rows_cards = [] # rows
for c in cards[:]: for c in cards[:]:
if c.rank in (ACE, KING): if c.rank in (ACE, KING):
if ((c.rank == ACE and c.color == RED) or cond = ((c.rank == ACE and c.color == RED) or
(c.rank == KING and c.color == BLACK)): (c.rank == KING and c.color == BLACK))
if cond:
cards.remove(c) cards.remove(c)
founds_cards.append(c) founds_cards.append(c)
elif c.deck == 0: elif c.deck == 0:
cards.remove(c) cards.remove(c)
rows_cards.append(c) rows_cards.append(c)
founds_cards.sort(lambda a, b: cmp((-a.rank, -a.suit), (-b.rank, -b.suit))) founds_cards.sort(key=lambda x: (-x.rank, -x.suit))
rows_cards.sort(lambda a, b: cmp((a.rank, a.suit), (b.rank, b.suit))) rows_cards.sort(key=lambda x: (x.rank, x.suit))
return cards+rows_cards+founds_cards return cards+rows_cards+founds_cards
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()
self.s.talon.dealRow() self.s.talon.dealRow()
self.s.talon.dealCards() # deal first card to WasteStack self.s.talon.dealCards() # deal first card to WasteStack
def fillStack(self, stack): def fillStack(self, stack):
if stack in self.s.rows[4:] and not stack.cards: if stack in self.s.rows[4:] and not stack.cards:
old_state = self.enterState(self.S_FILL) old_state = self.enterState(self.S_FILL)
@ -348,7 +363,6 @@ class Hemispheres(Game):
self.s.waste.moveMove(1, stack) self.s.waste.moveMove(1, stack)
self.leaveState(old_state) self.leaveState(old_state)
def shallHighlightMatch(self, stack1, card1, stack2, card2): def shallHighlightMatch(self, stack1, card1, stack2, card2):
# by color # by color
return card1.color == card2.color and abs(card1.rank-card2.rank) == 1 return card1.color == card2.color and abs(card1.rank-card2.rank) == 1
@ -384,6 +398,7 @@ class BigBen_Talon(DealRowTalonStack):
self.game.stopSamples() self.game.stopSamples()
return ncards return ncards
class BigBen_RowStack(SS_RowStack): class BigBen_RowStack(SS_RowStack):
def acceptsCards(self, from_stack, cards): def acceptsCards(self, from_stack, cards):
if not SS_RowStack.acceptsCards(self, from_stack, cards): if not SS_RowStack.acceptsCards(self, from_stack, cards):
@ -392,6 +407,7 @@ class BigBen_RowStack(SS_RowStack):
return False return False
return True return True
class BigBen(Game): class BigBen(Game):
Hint_Class = CautiousDefaultHint Hint_Class = CautiousDefaultHint
@ -422,10 +438,10 @@ class BigBen(Game):
(2.5, 3), (2.5, 3),
(1.5, 2.85), (1.5, 2.85),
(0.5, 2.5), (0.5, 2.5),
): ):
x = int(x0 + xx*l.XS) x = int(x0 + xx*l.XS)
y = int(y0 + yy*l.YS) y = int(y0 + yy*l.YS)
suit=(3,0,2,1)[rank%4] suit = (3, 0, 2, 1)[rank % 4]
max_cards = rank <= 4 and 8 or 9 max_cards = rank <= 4 and 8 or 9
s.foundations.append(SS_FoundationStack(x, y, self, suit=suit, s.foundations.append(SS_FoundationStack(x, y, self, suit=suit,
max_cards=max_cards, base_rank=rank, max_cards=max_cards, base_rank=rank,
@ -444,8 +460,8 @@ class BigBen(Game):
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
# move clock cards to top of the Talon (i.e. first cards to be dealt) # move clock cards to top of the Talon (i.e. first cards to be dealt)
C, S, H, D = range(4) # suits C, S, H, D = range(4) # suits
t = [(1,C), (2,H), (3,S), (4,D), (5,C), (6,H), t = [(1, C), (2, H), (3, S), (4, D), (5, C), (6, H),
(7,S), (8,D), (9,C), (JACK,H), (QUEEN,S), (KING,D)] (7, S), (8, D), (9, C), (JACK, H), (QUEEN, S), (KING, D)]
clocks = [] clocks = []
for c in cards[:]: for c in cards[:]:
if (c.rank, c.suit) in t: if (c.rank, c.suit) in t:
@ -455,7 +471,7 @@ class BigBen(Game):
if not t: if not t:
break break
# sort clocks reverse by rank # sort clocks reverse by rank
clocks.sort(lambda a, b: cmp(b.rank, a.rank)) clocks.sort(key=lambda x: x.rank)
return cards+clocks return cards+clocks
def startGame(self): def startGame(self):
@ -559,7 +575,7 @@ class Clock(Game):
(0.25, 0.5), (0.25, 0.5),
(1.25, 0.15), (1.25, 0.15),
(2.25, 0), (2.25, 0),
): ):
x = l.XM + xx*dx x = l.XM + xx*dx
y = l.YM + yy*l.YS y = l.YM + yy*l.YS
stack = Clock_RowStack(x, y, self, max_move=0) stack = Clock_RowStack(x, y, self, max_move=0)
@ -604,7 +620,6 @@ class Clock(Game):
return (), (), () return (), (), ()
# register the game # register the game
registerGame(GameInfo(261, GrandfathersClock, "Grandfather's Clock", registerGame(GameInfo(261, GrandfathersClock, "Grandfather's Clock",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED)) GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED))
@ -612,10 +627,9 @@ registerGame(GameInfo(682, Dial, "Dial",
GI.GT_1DECK_TYPE, 1, 1, GI.SL_LUCK)) GI.GT_1DECK_TYPE, 1, 1, GI.SL_LUCK))
registerGame(GameInfo(690, Hemispheres, "Hemispheres", registerGame(GameInfo(690, Hemispheres, "Hemispheres",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED, GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED,
altnames=("The Four Continents",) )) altnames=("The Four Continents",)))
registerGame(GameInfo(697, BigBen, "Big Ben", registerGame(GameInfo(697, BigBen, "Big Ben",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED)) GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(737, Clock, "Clock", registerGame(GameInfo(737, Clock, "Clock",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK, GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK,
altnames=("Travellers",) )) altnames=("Travellers",)))

92
pysollib/games/gypsy.py
View file

@ -24,20 +24,38 @@
__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.mfxutil import kwdefault from pysollib.mfxutil import kwdefault
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 KlondikeType_Hint, YukonType_Hint from pysollib.hint import KlondikeType_Hint, YukonType_Hint
from spider import Spider_SS_Foundation, Spider_RowStack, Spider_Hint from spider import Spider_SS_Foundation, Spider_RowStack, Spider_Hint
from pysollib.util import ACE, ANY_SUIT, KING, UNLIMITED_ACCEPTS, \
UNLIMITED_MOVES
from pysollib.stack import \
AC_RowStack, \
AbstractFoundationStack, \
BasicRowStack, \
DealRowTalonStack, \
InitialDealTalonStack, \
KingAC_RowStack, \
OpenStack, \
ReserveStack, \
SS_FoundationStack, \
SS_RowStack, \
Spider_SS_RowStack, \
Stack, \
TalonStack, \
WasteStack, \
WasteTalonStack, \
Yukon_AC_RowStack, \
StackWrapper
# ************************************************************************ # ************************************************************************
# * Gypsy # * Gypsy
@ -61,7 +79,8 @@ class Gypsy(Game):
if l.s.waste: if l.s.waste:
s.waste = WasteStack(l.s.waste.x, l.s.waste.y, self) s.waste = WasteStack(l.s.waste.x, l.s.waste.y, self)
for r in l.s.foundations: for r in l.s.foundations:
s.foundations.append(self.Foundation_Class(r.x, r.y, self, suit=r.suit)) s.foundations.append(
self.Foundation_Class(r.x, r.y, self, suit=r.suit))
for r in l.s.rows: for r in l.s.rows:
s.rows.append(self.RowStack_Class(r.x, r.y, self)) s.rows.append(self.RowStack_Class(r.x, r.y, self))
# default # default
@ -177,7 +196,8 @@ class DieRussische_RowStack(AC_RowStack):
class DieRussische(Gypsy): class DieRussische(Gypsy):
Talon_Class = InitialDealTalonStack Talon_Class = InitialDealTalonStack
Foundation_Class = StackWrapper(DieRussische_Foundation, min_cards=1, max_cards=8) Foundation_Class = StackWrapper(
DieRussische_Foundation, min_cards=1, max_cards=8)
RowStack_Class = DieRussische_RowStack RowStack_Class = DieRussische_RowStack
def createGame(self): def createGame(self):
@ -185,7 +205,8 @@ class DieRussische(Gypsy):
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
# move one Ace to bottom of the Talon (i.e. last card to be dealt) # move one Ace to bottom of the Talon (i.e. last card to be dealt)
return self._shuffleHookMoveToBottom(cards, lambda c: (c.rank == 0, c.suit), 1) return self._shuffleHookMoveToBottom(
cards, lambda c: (c.rank == 0, c.suit), 1)
def startGame(self): def startGame(self):
for i in range(6): for i in range(6):
@ -223,7 +244,9 @@ class MissMilligan(Gypsy):
l, s = Layout(self), self.s l, s = Layout(self), self.s
# set window # set window
self.setSize(l.XM + (1+max(8,rows))*l.XS, l.YM + (1+max(4, reserves))*l.YS+l.TEXT_HEIGHT) self.setSize(
l.XM + (1+max(8, rows))*l.XS,
l.YM + (1+max(4, reserves))*l.YS+l.TEXT_HEIGHT)
# create stacks # create stacks
x, y = l.XM, l.YM x, y = l.XM, l.YM
@ -234,7 +257,8 @@ class MissMilligan(Gypsy):
x, y = l.XM, y + l.YS x, y = l.XM, y + l.YS
rx, ry = x + l.XS - l.CW/2, y - l.CH/2 rx, ry = x + l.XS - l.CW/2, y - l.CH/2
for i in range(reserves): for i in range(reserves):
s.reserves.append(self.ReserveStack_Class(x, y+l.TEXT_HEIGHT, self)) s.reserves.append(
self.ReserveStack_Class(x, y+l.TEXT_HEIGHT, self))
y = y + l.YS y = y + l.YS
l.createText(s.talon, "s") l.createText(s.talon, "s")
if s.reserves: if s.reserves:
@ -330,6 +354,7 @@ class LexingtonHarp(MilliganHarp):
GAME_VERSION = 2 GAME_VERSION = 2
RowStack_Class = Yukon_AC_RowStack RowStack_Class = Yukon_AC_RowStack
Hint_Class = YukonType_Hint Hint_Class = YukonType_Hint
def getHighlightPilesStacks(self): def getHighlightPilesStacks(self):
return () return ()
@ -459,6 +484,7 @@ class Surprise_ReserveStack(ReserveStack):
return False return False
return len(self.game.s.talon.cards) == 0 return len(self.game.s.talon.cards) == 0
class Surprise(Gypsy): class Surprise(Gypsy):
def createGame(self, rows=8, reserves=1): def createGame(self, rows=8, reserves=1):
@ -628,15 +654,15 @@ class Trapdoor(Gypsy):
RowStack_Class = AC_RowStack RowStack_Class = AC_RowStack
def createGame(self, rows=8): def createGame(self, rows=8):
kw = {'rows' : rows, kw = {'rows': rows,
'waste' : 0, 'waste': 0,
'texts' : 1, 'texts': 1,
'reserves' : rows,} 'reserves': rows}
Layout(self).createGame(layout_method = Layout.gypsyLayout, Layout(self).createGame(layout_method=Layout.gypsyLayout,
talon_class = Trapdoor_Talon, talon_class=Trapdoor_Talon,
foundation_class = self.Foundation_Class, foundation_class=self.Foundation_Class,
row_class = self.RowStack_Class, row_class=self.RowStack_Class,
reserve_class = OpenStack, reserve_class=OpenStack,
**kw **kw
) )
@ -674,22 +700,24 @@ class TrapdoorSpider(Trapdoor):
class Flamenco(Gypsy): class Flamenco(Gypsy):
def createGame(self): def createGame(self):
kw = {'rows' : 8, kw = {'rows': 8,
'waste' : 0, 'waste': 0,
'texts' : 1,} 'texts': 1, }
foundation_class = ( foundation_class = (
SS_FoundationStack, SS_FoundationStack,
StackWrapper(SS_FoundationStack, base_rank=KING, dir=-1)) StackWrapper(SS_FoundationStack, base_rank=KING, dir=-1))
Layout(self).createGame(layout_method = Layout.gypsyLayout, Layout(self).createGame(layout_method=Layout.gypsyLayout,
talon_class = DealRowTalonStack, talon_class=DealRowTalonStack,
foundation_class = foundation_class, foundation_class=foundation_class,
row_class = AC_RowStack, row_class=AC_RowStack,
**kw **kw
) )
def _shuffleHook(self, cards): def _shuffleHook(self, cards):
return self._shuffleHookMoveToTop(cards, return self._shuffleHookMoveToTop(
lambda c: (c.rank in (ACE, KING) and c.deck == 0, (c.suit,c.rank))) cards,
lambda c: (c.rank in (ACE, KING) and c.deck == 0,
(c.suit, c.rank)))
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)
@ -859,7 +887,6 @@ class LockedCards(Game):
# define stack-groups # define stack-groups
l.defaultStackGroups() l.defaultStackGroups()
def startGame(self, rows=5): def startGame(self, rows=5):
self.s.talon.dealRow(rows=self.s.reserves, flip=0, frames=0) self.s.talon.dealRow(rows=self.s.reserves, flip=0, frames=0)
for i in range(rows-1): for i in range(rows-1):
@ -947,7 +974,6 @@ class Thirty(Game):
l.defaultAll() l.defaultAll()
def startGame(self): def startGame(self):
for i in range(4): for i in range(4):
self.s.talon.dealRow(frames=0) self.s.talon.dealRow(frames=0)
@ -959,7 +985,6 @@ class Thirty(Game):
getQuickPlayScore = Game._getSpiderQuickPlayScore getQuickPlayScore = Game._getSpiderQuickPlayScore
# register the game # register the game
registerGame(GameInfo(1, Gypsy, "Gypsy", registerGame(GameInfo(1, Gypsy, "Gypsy",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
@ -972,11 +997,12 @@ registerGame(GameInfo(119, DieKoenigsbergerin, "Die Koenigsbergerin",
registerGame(GameInfo(174, DieRussische, "Russian Patience", registerGame(GameInfo(174, DieRussische, "Russian Patience",
GI.GT_2DECK_TYPE | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL, GI.GT_2DECK_TYPE | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL,
ranks=(0, 6, 7, 8, 9, 10, 11, 12), ranks=(0, 6, 7, 8, 9, 10, 11, 12),
altnames=("Die Russische",) )) altnames=("Die Russische",)))
registerGame(GameInfo(62, MissMilligan, "Miss Milligan", registerGame(GameInfo(62, MissMilligan, "Miss Milligan",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(200, Nomad, "Nomad", registerGame(GameInfo(200, Nomad, "Nomad",
GI.GT_GYPSY | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GYPSY | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0,
GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(78, MilliganCell, "Milligan Cell", registerGame(GameInfo(78, MilliganCell, "Milligan Cell",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(217, MilliganHarp, "Milligan Harp", registerGame(GameInfo(217, MilliganHarp, "Milligan Harp",
@ -1011,7 +1037,7 @@ registerGame(GameInfo(566, Hypotenuse, "Hypotenuse",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(567, EternalTriangle, "Eternal Triangle", registerGame(GameInfo(567, EternalTriangle, "Eternal Triangle",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL, GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=('Lobachevsky',) )) altnames=('Lobachevsky',)))
registerGame(GameInfo(568, RightTriangle, "Right Triangle", registerGame(GameInfo(568, RightTriangle, "Right Triangle",
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL)) GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(580, Trapdoor, "Trapdoor", registerGame(GameInfo(580, Trapdoor, "Trapdoor",

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-fy-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-gy-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." );