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

+ new selection type: `by skill level'

Browse source 
+ new experimental options: `randomize_place'
* added columnbreak to favorites menu


git-svn-id: file:///home/shlomif/Backup/svn-dumps/PySolFC/svnsync-repos/pysolfc/PySolFC/trunk@11 efabe8c0-fbe8-4139-b769-b5e6d273206e
This commit is contained in:
skomoroh 2006-06-21 21:27:05 +00:00
parent bce72a93fa
commit 49adfd3513
84 changed files with 676 additions and 654 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
po/ru_pysol.po
View file

@ -6,7 +6,7 @@ msgid ""
msgstr ""
"Project-Id-Version: PySol 0.0.1\n"
"POT-Creation-Date: Sun Jun 11 10:16:01 2006\n"
"PO-Revision-Date: 2006-06-12 15:31+0400\n"
"PO-Revision-Date: 2006-06-20 01:10+0400\n"
"Last-Translator: Скоморох <skomoroh@gmail.com>\n"
"Language-Team: Russian <ru@li.org>\n"
"MIME-Version: 1.0\n"
@ -1143,7 +1143,7 @@ msgstr "Клен"
#: pysollib/games/ultra/hanafuda_common.py:69
msgid "Paulownia"
msgstr ""
msgstr "Павловния"
#: pysollib/games/ultra/hanafuda_common.py:69
msgid "Willow"

9
pysollib/acard.py
View file

@ -35,11 +35,11 @@
# imports
from random import randint
# PySol imports
from mfxutil import SubclassResponsibility
# /***********************************************************************
# //
# ************************************************************************/
@ -79,6 +79,7 @@ class AbstractCard:
self.suit = suit
self.color = suit / 2
self.rank = rank
self.game = game
self.x = x
self.y = y
self.item = None
@ -99,7 +100,11 @@ class AbstractCard:
def moveTo(self, x, y):
# Move the card to absolute position (x, y).
# The card remains hidden.
self.moveBy(x - self.x + self.hide_x, y - self.y + self.hide_y)
dx, dy = 0, 0
if self.game.app.opt.randomize_place:
d = 1
dx, dy = randint(-d, d), randint(-d, d)
self.moveBy(x - self.x + self.hide_x + dx, y - self.y + self.hide_y + dy)
def moveBy(self, dx, dy):
# Move the card by (dx, dy).

2
pysollib/app.py
View file

@ -196,6 +196,7 @@ class Options:
self.splashscreen = True
self.sticky_mouse = False
self.negative_bottom = False
self.randomize_place = True
self.cache_carsets = True
# defaults & constants
self.setDefaults()
@ -228,6 +229,7 @@ class Options:
CSI.TYPE_DASHAVATARA_GANJIFA: ("Dashavatara Ganjifa", ""),
CSI.TYPE_TRUMP_ONLY: ("Matrix", ""),
}
self.randomize_place = True
# not changeable options
def setConstants(self):

34
pysollib/gamedb.py
View file

@ -109,6 +109,13 @@ class GI:
GT_SCORE = 1 << 20 # game has some type of scoring
GT_SEPARATE_DECKS = 1 << 21
GT_XORIGINAL = 1 << 22 # original games by other people, not playable
# skill level
SL_LUCK = 1
SL_MOSTLY_LUCK = 2
SL_BALANCED = 3
SL_MOSTLY_SKILL = 4
SL_SKILL = 5
#
TYPE_NAMES = {
GT_BAKERS_DOZEN: n_("Baker's Dozen"),
GT_BELEAGUERED_CASTLE: n_("Beleaguered Castle"),
@ -167,23 +174,6 @@ class GI:
(n_("Four-Deck games"),lambda gi, gt=GT_4DECK_TYPE: gi.si.game_type == gt),
)
## SELECT_SPECIAL_GAME_BY_TYPE = (
## ("Dashavatara Ganjifa type", lambda gi, gt=GT_DASHAVATARA_GANJIFA: gi.si.game_type == gt),
## ("Ganjifa type", lambda gi, gt=(GT_MUGHAL_GANJIFA, GT_NAVAGRAHA_GANJIFA, GT_DASHAVATARA_GANJIFA,): gi.si.game_type in gt),
## ("Hanafuda type", lambda gi, gt=GT_HANAFUDA: gi.si.game_type == gt),
## ("Hex A Deck type", lambda gi, gt=GT_HEXADECK: gi.si.game_type == gt),
## ("Mahjongg type", lambda gi, gt=GT_MAHJONGG: gi.si.game_type == gt),
## ("Matrix type", lambda gi, gt=GT_MATRIX: gi.si.game_type == gt),
## ("Mughal Ganjifa type", lambda gi, gt=GT_MUGHAL_GANJIFA: gi.si.game_type == gt),
## ("Navagraha Ganjifa type", lambda gi, gt=GT_NAVAGRAHA_GANJIFA: gi.si.game_type == gt),
## ("Memory type", lambda gi, gt=GT_MEMORY: gi.si.game_type == gt),
## ("Poker type", lambda gi, gt=GT_POKER_TYPE: gi.si.game_type == gt),
## ("Puzzle type", lambda gi, gt=GT_PUZZLE_TYPE: gi.si.game_type == gt),
## ("Tarock type", lambda gi, gt=GT_TAROCK: gi.si.game_type == gt),
## )
SELECT_ORIGINAL_GAME_BY_TYPE = (
(n_("French type"), lambda gi, gf=GT_ORIGINAL, gt=(GT_HANAFUDA, GT_HEXADECK, GT_MUGHAL_GANJIFA, GT_NAVAGRAHA_GANJIFA, GT_DASHAVATARA_GANJIFA, GT_TAROCK,): gi.si.game_flags & gf and gi.si.game_type not in gt),
(n_("Ganjifa type"), lambda gi, gf=GT_ORIGINAL, gt=(GT_MUGHAL_GANJIFA, GT_NAVAGRAHA_GANJIFA, GT_DASHAVATARA_GANJIFA,): gi.si.game_flags & gf and gi.si.game_type in gt),
@ -200,7 +190,6 @@ class GI:
(n_("Tarock type"), lambda gi, gf=GT_CONTRIB, gt=GT_TAROCK: gi.si.game_flags & gf and gi.si.game_type == gt),
)
# -----
SELECT_ORIENTAL_GAME_BY_TYPE = (
(n_("Dashavatara Ganjifa type"), lambda gi, gt=GT_DASHAVATARA_GANJIFA: gi.si.game_type == gt),
(n_("Ganjifa type"), lambda gi, gt=(GT_MUGHAL_GANJIFA, GT_NAVAGRAHA_GANJIFA, GT_DASHAVATARA_GANJIFA,): gi.si.game_type in gt),
@ -391,10 +380,13 @@ class GameInfoException(Exception):
class GameInfo(Struct):
def __init__(self, id, gameclass, name,
game_type, decks, redeals,
skill_level=None,
# keyword arguments:
si={}, category=0, short_name=None, altnames=(),
si={}, category=0,
short_name=None, altnames=(),
suits=range(4), ranks=range(13), trumps=(),
rules_filename=None):
rules_filename=None,
):
def to_unicode(s):
if not type(s) is unicode:
return unicode(s, 'utf-8')
@ -463,7 +455,7 @@ class GameInfo(Struct):
name=name, short_name=short_name,
altnames=tuple(altnames),
decks=decks, redeals=redeals, ncards=ncards,
category=category,
category=category, skill_level=skill_level,
suits=tuple(suits), ranks=tuple(ranks), trumps=tuple(trumps),
si=gi_si, rules_filename=rules_filename, plugin=0)

10
pysollib/games/acesup.py
View file

@ -252,14 +252,14 @@ class AcesUp5(AcesUp):
# register the game
registerGame(GameInfo(903, AcesUp, "Aces Up", # was: 52
GI.GT_1DECK_TYPE, 1, 0,
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.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK))
registerGame(GameInfo(213, RussianAces, "Russian Aces",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK))
registerGame(GameInfo(130, PerpetualMotion, "Perpetual Motion",
GI.GT_1DECK_TYPE, 1, -1,
GI.GT_1DECK_TYPE, 1, -1, GI.SL_MOSTLY_LUCK,
altnames="First Law"))
registerGame(GameInfo(353, AcesUp5, "Aces Up 5",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_LUCK))

6
pysollib/games/algerian.py
View file

@ -161,9 +161,9 @@ class AlgerianPatience3(Carthage):
# register the game
registerGame(GameInfo(321, Carthage, "Carthage",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(322, AlgerianPatience, "Algerian Patience",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(457, AlgerianPatience3, "Algerian Patience (3 decks)",
GI.GT_3DECK_TYPE | GI.GT_ORIGINAL, 3, 0))
GI.GT_3DECK_TYPE | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))

14
pysollib/games/auldlangsyne.py
View file

@ -485,19 +485,19 @@ class Acquaintance(AuldLangSyne):
# register the game
registerGame(GameInfo(172, TamOShanter, "Tam O'Shanter",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_LUCK))
registerGame(GameInfo(95, AuldLangSyne, "Auld Lang Syne",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_LUCK))
registerGame(GameInfo(173, Strategy, "Strategy",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(123, Interregnum, "Interregnum",
GI.GT_NUMERICA, 2, 0))
GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(296, Colorado, "Colorado",
GI.GT_NUMERICA, 2, 0))
GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(406, Amazons, "Amazons",
GI.GT_NUMERICA, 1, -1,
GI.GT_NUMERICA, 1, -1, GI.SL_LUCK,
ranks=(0, 6, 7, 8, 9, 10, 11),
))
registerGame(GameInfo(490, Acquaintance, "Acquaintance",
GI.GT_NUMERICA, 1, 2))
GI.GT_NUMERICA, 1, 2, GI.SL_BALANCED))

20
pysollib/games/bakersdozen.py
View file

@ -322,23 +322,23 @@ class RippleFan(CastlesInSpain):
# register the game
registerGame(GameInfo(83, CastlesInSpain, "Castles in Spain",
GI.GT_BAKERS_DOZEN, 1, 0))
GI.GT_BAKERS_DOZEN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(84, Martha, "Martha",
GI.GT_BAKERS_DOZEN, 1, 0))
GI.GT_BAKERS_DOZEN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(31, BakersDozen, "Baker's Dozen",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(85, SpanishPatience, "Spanish Patience",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(86, GoodMeasure, "Good Measure",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(104, Cruel, "Cruel",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, -1))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(291, RoyalFamily, "Royal Family",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 1))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 1, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(308, PortugueseSolitaire, "Portuguese Solitaire",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(404, Perseverance, "Perseverance",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 2))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 1, 2, GI.SL_BALANCED))
registerGame(GameInfo(369, RippleFan, "Ripple Fan",
GI.GT_BAKERS_DOZEN, 1, -1))
GI.GT_BAKERS_DOZEN, 1, -1, GI.SL_MOSTLY_SKILL))

14
pysollib/games/bakersgame.py
View file

@ -349,18 +349,18 @@ class Opus(Penguin):
# register the game
registerGame(GameInfo(45, BakersGame, "Baker's Game",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(26, KingOnlyBakersGame, "King Only Baker's Game",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(258, EightOff, "Eight Off",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(9, SeahavenTowers, "Seahaven Towers",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0,
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL,
altnames=("Sea Towers", "Towers") ))
registerGame(GameInfo(6, RelaxedSeahavenTowers, "Relaxed Seahaven Towers",
GI.GT_FREECELL | GI.GT_RELAXED | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_RELAXED | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(64, Penguin, "Penguin",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0,
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("Beak and Flipper",) ))
registerGame(GameInfo(427, Opus, "Opus",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))

32
pysollib/games/beleagueredcastle.py
View file

@ -686,34 +686,34 @@ class CastleMount(Lightweight):
# register the game
registerGame(GameInfo(146, StreetsAndAlleys, "Streets and Alleys",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
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.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.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.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(148, Chessboard, "Chessboard",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(300, Stronghold, "Stronghold",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(301, Fastness, "Fastness",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(306, Zerline, "Zerline",
GI.GT_BELEAGUERED_CASTLE, 2, 0))
GI.GT_BELEAGUERED_CASTLE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(324, Bastion, "Bastion",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(325, TenByOne, "Ten by One",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(351, Chequers, "Chequers",
GI.GT_BELEAGUERED_CASTLE, 2, 0))
GI.GT_BELEAGUERED_CASTLE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(393, CastleOfIndolence, "Castle of Indolence",
GI.GT_BELEAGUERED_CASTLE, 2, 0))
GI.GT_BELEAGUERED_CASTLE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(395, Zerline3Decks, "Zerline (3 decks)",
GI.GT_BELEAGUERED_CASTLE | GI.GT_ORIGINAL, 3, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(400, Rittenhouse, "Rittenhouse",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 2, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(507, Lightweight, "Lightweight",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(508, CastleMount, "Castle Mount",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 3, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 3, 0, GI.SL_MOSTLY_SKILL))

10
pysollib/games/bisley.py
View file

@ -245,13 +245,13 @@ class Mancunian(Realm):
# register the game
registerGame(GameInfo(290, Bisley, "Bisley",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0))
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.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.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.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.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))

12
pysollib/games/braid.py
View file

@ -379,16 +379,16 @@ class BigBraid(Braid):
# register the game
registerGame(GameInfo(12, Braid, "Braid",
GI.GT_NAPOLEON, 2, 2,
GI.GT_NAPOLEON, 2, 2, GI.SL_BALANCED,
altnames=("Der Zopf", "Plait", "Pigtail") ))
registerGame(GameInfo(175, LongBraid, "Long Braid",
GI.GT_NAPOLEON, 2, 2,
GI.GT_NAPOLEON, 2, 2, GI.SL_BALANCED,
altnames=("Der lange Zopf",) ))
registerGame(GameInfo(358, Fort, "Fort",
GI.GT_NAPOLEON, 2, 2))
GI.GT_NAPOLEON, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(376, Backbone, "Backbone",
GI.GT_NAPOLEON, 2, 0))
GI.GT_NAPOLEON, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(377, BackbonePlus, "Backbone +",
GI.GT_NAPOLEON, 2, 0))
GI.GT_NAPOLEON, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(510, BigBraid, "Big Braid",
GI.GT_NAPOLEON, 3, 2))
GI.GT_NAPOLEON | GI.GT_ORIGINAL, 3, 2, GI.SL_BALANCED))

10
pysollib/games/bristol.py
View file

@ -344,13 +344,13 @@ class Spike(Dover):
# register the game
registerGame(GameInfo(42, Bristol, "Bristol",
GI.GT_FAN_TYPE, 1, 0))
GI.GT_FAN_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(214, Belvedere, "Belvedere",
GI.GT_FAN_TYPE, 1, 0))
GI.GT_FAN_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(266, Dover, "Dover",
GI.GT_FAN_TYPE, 2, 0))
GI.GT_FAN_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(425, NewYork, "New York",
GI.GT_FAN_TYPE, 2, 0))
GI.GT_FAN_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(468, Spike, "Spike",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_BALANCED))

4
pysollib/games/buffalobill.py
View file

@ -104,8 +104,8 @@ class LittleBillie(BuffaloBill):
# register the game
registerGame(GameInfo(338, BuffaloBill, "Buffalo Bill",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(421, LittleBillie, "Little Billie",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))

6
pysollib/games/calculation.py
View file

@ -267,12 +267,12 @@ class BetsyRoss(Calculation):
# register the game
registerGame(GameInfo(256, Calculation, "Calculation",
GI.GT_1DECK_TYPE, 1, 0,
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("Progression",) ))
registerGame(GameInfo(94, Hopscotch, "Hopscotch",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(134, BetsyRoss, "Betsy Ross",
GI.GT_1DECK_TYPE, 1, 2,
GI.GT_1DECK_TYPE, 1, 2, GI.SL_MOSTLY_LUCK,
altnames=("Fairest", "Four Kings", "Musical Patience",
"Quadruple Alliance", "Plus Belle") ))

2
pysollib/games/camelot.py
View file

@ -215,5 +215,5 @@ class Camelot(Game):
# register the game
registerGame(GameInfo(280, Camelot, "Camelot",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))

38
pysollib/games/canfield.py
View file

@ -670,43 +670,43 @@ class Demon(Canfield):
# register the game
registerGame(GameInfo(105, Canfield, "Canfield", # was: 262
GI.GT_CANFIELD | GI.GT_CONTRIB, 1, -1))
GI.GT_CANFIELD | GI.GT_CONTRIB, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(101, SuperiorCanfield, "Superior Canfield",
GI.GT_CANFIELD, 1, -1))
GI.GT_CANFIELD, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(99, Rainfall, "Rainfall",
GI.GT_CANFIELD | GI.GT_ORIGINAL, 1, 2))
GI.GT_CANFIELD | GI.GT_ORIGINAL, 1, 2, GI.SL_BALANCED))
registerGame(GameInfo(108, Rainbow, "Rainbow",
GI.GT_CANFIELD, 1, 0))
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(100, Storehouse, "Storehouse",
GI.GT_CANFIELD, 1, 2,
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.GT_CANFIELD, 1, 0, GI.SL_BALANCED,
altnames="Kansas"))
registerGame(GameInfo(106, DoubleCanfield, "Double Canfield", # was: 22
GI.GT_CANFIELD, 2, -1))
GI.GT_CANFIELD, 2, -1, GI.SL_BALANCED))
registerGame(GameInfo(103, AmericanToad, "American Toad",
GI.GT_CANFIELD, 2, 1))
GI.GT_CANFIELD, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(102, VariegatedCanfield, "Variegated Canfield",
GI.GT_CANFIELD, 2, 2))
GI.GT_CANFIELD, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(112, EagleWing, "Eagle Wing",
GI.GT_CANFIELD, 1, 2))
GI.GT_CANFIELD, 1, 2, GI.SL_BALANCED))
registerGame(GameInfo(315, Gate, "Gate",
GI.GT_CANFIELD, 1, 0))
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(316, LittleGate, "Little Gate",
GI.GT_CANFIELD, 1, 0))
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(360, Munger, "Munger",
GI.GT_CANFIELD, 1, 0))
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(396, TripleCanfield, "Triple Canfield",
GI.GT_CANFIELD, 3, -1))
GI.GT_CANFIELD, 3, -1, GI.SL_BALANCED))
registerGame(GameInfo(403, Acme, "Acme",
GI.GT_CANFIELD, 1, 1))
GI.GT_CANFIELD, 1, 1, GI.SL_BALANCED))
registerGame(GameInfo(413, Duke, "Duke",
GI.GT_CANFIELD, 1, 2))
GI.GT_CANFIELD, 1, 2, GI.SL_BALANCED))
registerGame(GameInfo(422, Minerva, "Minerva",
GI.GT_CANFIELD, 1, 1))
GI.GT_CANFIELD, 1, 1, GI.SL_BALANCED))
registerGame(GameInfo(476, Demon, "Demon",
GI.GT_CANFIELD, 2, -1))
GI.GT_CANFIELD, 2, -1, GI.SL_BALANCED))
registerGame(GameInfo(494, Mystique, "Mystique",
GI.GT_CANFIELD, 1, 0))
GI.GT_CANFIELD, 1, 0, GI.SL_BALANCED))

4
pysollib/games/capricieuse.py
View file

@ -139,7 +139,7 @@ class Nationale(Capricieuse):
# register the game
registerGame(GameInfo(292, Capricieuse, "Capricieuse",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 2, 2))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 2, 2, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(293, Nationale, "Nationale",
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 2, 0))
GI.GT_BAKERS_DOZEN | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))

2
pysollib/games/contrib/sanibel.py
View file

@ -71,5 +71,5 @@ class Sanibel(Gypsy):
registerGame(GameInfo(201, Sanibel, "Sanibel",
GI.GT_YUKON | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0))
GI.GT_YUKON | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))

24
pysollib/games/curdsandwhey.py
View file

@ -389,27 +389,27 @@ class SweetSixteen(TrustyTwelve):
# register the game
registerGame(GameInfo(294, CurdsAndWhey, "Curds and Whey",
GI.GT_SPIDER | GI.GT_OPEN, 1, 0))
GI.GT_SPIDER | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(311, Dumfries, "Dumfries",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(312, Galloway, "Galloway",
GI.GT_1DECK_TYPE, 1, 0))
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.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(348, Arachnida, "Arachnida",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(349, MissMuffet, "Miss Muffet",
GI.GT_SPIDER | GI.GT_OPEN, 1, 0))
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.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.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(415, BavarianPatience, "Bavarian Patience",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(480, TrustyTwelve, "Trusty Twelve",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(481, KnottyNines, "Knotty Nines",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(482, SweetSixteen, "Sweet Sixteen",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))

2
pysollib/games/dieboesesieben.py
View file

@ -120,7 +120,7 @@ class DieBoeseSieben(Game):
# register the game
registerGame(GameInfo(120, DieBoeseSieben, "Bad Seven",
GI.GT_2DECK_TYPE, 2, 1,
GI.GT_2DECK_TYPE, 2, 1, GI.SL_MOSTLY_LUCK,
ranks=(0, 6, 7, 8, 9, 10, 11, 12),
altnames=("Die böse Sieben",) ))

12
pysollib/games/diplomat.py
View file

@ -227,15 +227,15 @@ class LittleNapoleon(Diplomat):
# register the game
registerGame(GameInfo(149, Diplomat, "Diplomat",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(151, LadyPalk, "Lady Palk",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(150, Congress, "Congress",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(433, RowsOfFour, "Rows of Four",
GI.GT_FORTY_THIEVES, 2, 2))
GI.GT_FORTY_THIEVES, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(485, Dieppe, "Dieppe",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(489, LittleNapoleon, "Little Napoleon",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))

2
pysollib/games/doublets.py
View file

@ -138,5 +138,5 @@ class Doublets(Game):
# register the game
registerGame(GameInfo(111, Doublets, "Doublets",
GI.GT_1DECK_TYPE, 1, 2))
GI.GT_1DECK_TYPE, 1, 2, GI.SL_MOSTLY_LUCK))

2
pysollib/games/eiffeltower.py
View file

@ -120,7 +120,7 @@ class StrictEiffelTower(EiffelTower):
# register the game
registerGame(GameInfo(16, EiffelTower, "Eiffel Tower",
GI.GT_PAIRING_TYPE, 2, 0))
GI.GT_PAIRING_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
##registerGame(GameInfo(801, StrictEiffelTower, "Strict Eiffel Tower",
## GI.GT_PAIRING_TYPE, 2, 0))

28
pysollib/games/fan.py
View file

@ -566,33 +566,33 @@ class BoxFan(Fan):
# register the game
registerGame(GameInfo(56, Fan, "Fan",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(87, ScotchPatience, "Scotch Patience",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(57, Shamrocks, "Shamrocks",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(901, LaBelleLucie, "La Belle Lucie", # was: 32, 82
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2,
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL,
altnames=("Fair Lucy", "Midnight Oil") ))
registerGame(GameInfo(132, SuperFlowerGarden, "Super Flower Garden",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(128, ThreeShufflesAndADraw, "Three Shuffles and a Draw",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(88, Trefoil, "Trefoil",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(227, Intelligence, "Intelligence",
GI.GT_FAN_TYPE, 2, 2))
GI.GT_FAN_TYPE, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(340, IntelligencePlus, "Intelligence +",
GI.GT_FAN_TYPE, 2, 2))
GI.GT_FAN_TYPE, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(268, HouseInTheWood, "House in the Wood",
GI.GT_FAN_TYPE | GI.GT_OPEN, 2, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(317, HouseOnTheHill, "House on the Hill",
GI.GT_FAN_TYPE | GI.GT_OPEN, 2, 0,
GI.GT_FAN_TYPE | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL,
rules_filename='houseinthewood.html'))
registerGame(GameInfo(320, CloverLeaf, "Clover Leaf",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(347, FreeFan, "Free Fan",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(385, BoxFan, "Box Fan",
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_FAN_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))

74
pysollib/games/fortythieves.py
View file

@ -748,81 +748,81 @@ class Squadron(FortyThieves):
# register the game
registerGame(GameInfo(13, FortyThieves, "Forty Thieves",
GI.GT_FORTY_THIEVES, 2, 0,
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.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(228, Limited, "Limited",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(79, WaningMoon, "Waning Moon",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(125, Lucas, "Lucas",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(109, Deuces, "Deuces",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(196, Corona, "Corona",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(195, Quadrangle, "Quadrangle",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(110, Courtyard, "Courtyard",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(23, FortyAndEight, "Forty and Eight",
GI.GT_FORTY_THIEVES, 2, 1))
GI.GT_FORTY_THIEVES, 2, 1, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(115, LittleForty, "Little Forty", # was: 72
GI.GT_FORTY_THIEVES, 2, 3))
GI.GT_FORTY_THIEVES, 2, 3, GI.SL_BALANCED))
registerGame(GameInfo(76, Streets, "Streets",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(73, Maria, "Maria",
GI.GT_FORTY_THIEVES, 2, 0,
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED,
altnames=("Maria Luisa",) ))
registerGame(GameInfo(70, NumberTen, "Number Ten",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(71, RankAndFile, "Rank and File",
GI.GT_FORTY_THIEVES, 2, 0,
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED,
altnames=("Dress Parade") ))
registerGame(GameInfo(197, TripleLine, "Triple Line",
GI.GT_FORTY_THIEVES | GI.GT_XORIGINAL, 2, 1))
GI.GT_FORTY_THIEVES | GI.GT_XORIGINAL, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(126, RedAndBlack, "Red and Black", # was: 75
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(113, Zebra, "Zebra",
GI.GT_FORTY_THIEVES, 2, 1))
GI.GT_FORTY_THIEVES, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(69, Indian, "Indian",
GI.GT_FORTY_THIEVES, 2, 0,
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED,
altnames=("Indian Patience",) ))
registerGame(GameInfo(74, Midshipman, "Midshipman",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(198, NapoleonsExile, "Napoleon's Exile",
GI.GT_FORTY_THIEVES | GI.GT_XORIGINAL, 2, 0))
GI.GT_FORTY_THIEVES | GI.GT_XORIGINAL, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(131, DoubleRail, "Double Rail",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(199, SingleRail, "Single Rail",
GI.GT_FORTY_THIEVES, 1, 0))
GI.GT_FORTY_THIEVES, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(295, NapoleonsSquare, "Napoleon's Square",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(310, Emperor, "Emperor",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(323, Octave, "Octave",
GI.GT_FORTY_THIEVES, 2, 1))
GI.GT_FORTY_THIEVES, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(332, Mumbai, "Mumbai",
GI.GT_FORTY_THIEVES, 3, 0))
GI.GT_FORTY_THIEVES, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(411, CarreNapoleon, "Carre Napoleon",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(416, FortunesFavor, "Fortune's Favor",
GI.GT_FORTY_THIEVES, 1, 0))
GI.GT_FORTY_THIEVES, 1, 0, GI.SL_LUCK))
registerGame(GameInfo(426, Octagon, "Octagon",
GI.GT_FORTY_THIEVES, 2, 3))
GI.GT_FORTY_THIEVES, 2, 3, GI.SL_BALANCED))
registerGame(GameInfo(440, Squadron, "Squadron",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(462, Josephine, "Josephine",
GI.GT_FORTY_THIEVES, 2, 0))
GI.GT_FORTY_THIEVES, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(493, MarieRose, "Marie Rose",
GI.GT_FORTY_THIEVES, 3, 0))
GI.GT_FORTY_THIEVES, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(503, BigStreets, "Big Streets",
GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0))
GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(504, NumberTwelve, "Number Twelve",
GI.GT_FORTY_THIEVES| GI.GT_ORIGINAL, 3, 0))
GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0, GI.SL_BALANCED))
registerGame(GameInfo(505, BigCourtyard, "Big Courtyard",
GI.GT_FORTY_THIEVES| GI.GT_ORIGINAL, 3, 0))
GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0, GI.SL_BALANCED))
registerGame(GameInfo(506, Express, "Express",
GI.GT_FORTY_THIEVES| GI.GT_ORIGINAL, 3, 0))
GI.GT_FORTY_THIEVES | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))

34
pysollib/games/freecell.py
View file

@ -507,39 +507,39 @@ class FourColours(FreeCell):
# register the game
registerGame(GameInfo(5, RelaxedFreeCell, "Relaxed FreeCell",
GI.GT_FREECELL | GI.GT_RELAXED | GI.GT_OPEN, 1, 0))
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.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(46, ForeCell, "ForeCell",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
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.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.GT_FREECELL | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(265, TripleFreecell, "Triple FreeCell",
GI.GT_FREECELL | GI.GT_OPEN, 3, 0))
GI.GT_FREECELL | GI.GT_OPEN, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(336, ChallengeFreeCell, "Challenge FreeCell",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0,
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL,
rules_filename='freecell.html'))
registerGame(GameInfo(337, SuperChallengeFreeCell, "Super Challenge FreeCell",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(363, Spidercells, "Spidercells",
GI.GT_SPIDER | GI.GT_OPEN, 1, 0))
GI.GT_SPIDER | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(364, SevenByFour, "Seven by Four",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(365, SevenByFive, "Seven by Five",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(383, Bath, "Bath",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_SKILL))
registerGame(GameInfo(394, Clink, "Clink",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(448, Repair, "Repair",
GI.GT_FREECELL | GI.GT_OPEN, 2, 0))
GI.GT_FREECELL | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(451, Cell11, "Cell 11",
GI.GT_FREECELL | GI.GT_OPEN, 3, 0))
GI.GT_FREECELL | GI.GT_OPEN, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(464, FourColours, "Four Colours",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(509, BigCell, "Big Cell",
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 3, 0))
GI.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))

2
pysollib/games/glenwood.py
View file

@ -182,5 +182,5 @@ class Glenwood(Game):
# register the game
registerGame(GameInfo(282, Glenwood, "Glenwood",
GI.GT_CANFIELD, 1, 1))
GI.GT_CANFIELD, 1, 1, GI.SL_BALANCED))

20
pysollib/games/golf.py
View file

@ -612,23 +612,23 @@ class Robert(Game):
# register the game
registerGame(GameInfo(36, Golf, "Golf",
GI.GT_GOLF, 1, 0))
GI.GT_GOLF, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(259, DeadKingGolf, "Dead King Golf",
GI.GT_GOLF, 1, 0))
GI.GT_GOLF, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(260, RelaxedGolf, "Relaxed Golf",
GI.GT_GOLF | GI.GT_RELAXED, 1, 0))
GI.GT_GOLF | GI.GT_RELAXED, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(40, Elevator, "Elevator",
GI.GT_GOLF, 1, 0,
GI.GT_GOLF, 1, 0, GI.SL_BALANCED,
altnames=("Egyptian Solitaire", "Pyramid Golf") ))
registerGame(GameInfo(237, TriPeaks, "Tri Peaks",
GI.GT_GOLF | GI.GT_SCORE, 1, 0))
GI.GT_GOLF | GI.GT_SCORE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(98, BlackHole, "Black Hole",
GI.GT_GOLF | GI.GT_OPEN, 1, 0))
GI.GT_GOLF | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(267, FourLeafClovers, "Four Leaf Clovers",
GI.GT_GOLF | GI.GT_OPEN, 1, 0))
GI.GT_GOLF | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(281, Escalator, "Escalator",
GI.GT_GOLF, 1, 0))
GI.GT_GOLF, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(405, AllInARow, "All in a Row",
GI.GT_GOLF | GI.GT_OPEN, 1, 0))
GI.GT_GOLF | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(432, Robert, "Robert",
GI.GT_GOLF, 1, 2))
GI.GT_GOLF, 1, 2, GI.SL_LUCK))

2
pysollib/games/grandfathersclock.py
View file

@ -138,5 +138,5 @@ class GrandfathersClock(Game):
# register the game
registerGame(GameInfo(261, GrandfathersClock, "Grandfather's Clock",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_BALANCED))

44
pysollib/games/gypsy.py
View file

@ -541,49 +541,49 @@ class Millie(Gypsy):
# register the game
registerGame(GameInfo(1, Gypsy, "Gypsy",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(65, Giant, "Giant",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(3, Irmgard, "Irmgard",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(119, DieKoenigsbergerin, "Die Königsbergerin",
GI.GT_GYPSY, 2, 0))
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.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.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.GT_GYPSY | GI.GT_CONTRIB | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(78, MilliganCell, "Milligan Cell",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(217, MilliganHarp, "Milligan Harp",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(218, Carlton, "Carlton",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(68, LexingtonHarp, "Lexington Harp",
GI.GT_YUKON, 2, 0))
GI.GT_YUKON, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(154, Brunswick, "Brunswick",
GI.GT_YUKON, 2, 0))
GI.GT_YUKON, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(121, Mississippi, "Mississippi",
GI.GT_YUKON | GI.GT_XORIGINAL, 2, 0))
GI.GT_YUKON | GI.GT_XORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(122, Griffon, "Griffon",
GI.GT_YUKON | GI.GT_XORIGINAL, 2, 0))
GI.GT_YUKON | GI.GT_XORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(226, Blockade, "Blockade",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(412, Cone, "Cone",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(463, Surprise, "Surprise",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(469, PhantomBlockade, "Phantom Blockade",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(478, Elba, "Elba",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(486, ImperialGuards, "Imperial Guards",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(487, Millie, "Millie",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(498, Steve, "Steve",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_BALANCED))

20
pysollib/games/harp.py
View file

@ -213,24 +213,24 @@ class Arabella(DoubleKlondike):
# register the game
registerGame(GameInfo(21, DoubleKlondike, "Double Klondike",
GI.GT_KLONDIKE, 2, -1))
GI.GT_KLONDIKE, 2, -1, GI.SL_BALANCED))
registerGame(GameInfo(28, DoubleKlondikeByThrees, "Double Klondike by Threes",
GI.GT_KLONDIKE, 2, -1))
GI.GT_KLONDIKE, 2, -1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(25, Gargantua, "Gargantua",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(15, BigHarp, "Big Harp",
GI.GT_KLONDIKE, 2, 0,
GI.GT_KLONDIKE, 2, 0, GI.SL_BALANCED,
altnames=("Die große Harfe",) ))
registerGame(GameInfo(51, Steps, "Steps",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(273, TripleKlondike, "Triple Klondike",
GI.GT_KLONDIKE, 3, -1))
GI.GT_KLONDIKE, 3, -1, GI.SL_BALANCED))
registerGame(GameInfo(274, TripleKlondikeByThrees, "Triple Klondike by Threes",
GI.GT_KLONDIKE, 3, -1))
GI.GT_KLONDIKE, 3, -1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(495, LadyJane, "Lady Jane",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(496, Inquisitor, "Inquisitor",
GI.GT_KLONDIKE, 2, 2))
GI.GT_KLONDIKE, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(497, Arabella, "Arabella",
GI.GT_KLONDIKE, 3, 0))
GI.GT_KLONDIKE, 3, 0, GI.SL_BALANCED))

2
pysollib/games/headsandtails.py
View file

@ -136,7 +136,7 @@ class HeadsAndTails(Game):
# register the game
registerGame(GameInfo(307, HeadsAndTails, "Heads and Tails",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

12
pysollib/games/katzenschwanz.py
View file

@ -335,18 +335,18 @@ class Deep(DerKatzenschwanz):
# register the game
registerGame(GameInfo(141, DerKatzenschwanz, "Cat's Tail",
GI.GT_FREECELL | GI.GT_OPEN, 2, 0,
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.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.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.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.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.GT_FREECELL | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))

102
pysollib/games/klondike.py
View file

@ -608,7 +608,7 @@ class AgnesBernauer(Jane):
Foundation_Class = StackWrapper(SS_FoundationStack, mod=13, base_rank=NO_RANK, max_move=0)
def createGame(self):
Jane.createGame(self, max_rounds=1, waste=0, texts=1)
Jane.createGame(self, max_rounds=1, waste=0, texts=0)
def startGame(self):
Jane.startGame(self, flip=1)
@ -1052,107 +1052,107 @@ class Whitehorse(Klondike):
# register the game
registerGame(GameInfo(2, Klondike, "Klondike",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(61, CasinoKlondike, "Casino Klondike",
GI.GT_KLONDIKE | GI.GT_SCORE, 1, 2))
GI.GT_KLONDIKE | GI.GT_SCORE, 1, 2, GI.SL_BALANCED))
registerGame(GameInfo(129, VegasKlondike, "Vegas Klondike",
GI.GT_KLONDIKE | GI.GT_SCORE, 1, 0))
GI.GT_KLONDIKE | GI.GT_SCORE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(18, KlondikeByThrees, "Klondike by Threes",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(58, ThumbAndPouch, "Thumb and Pouch",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(67, Whitehead, "Whitehead",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(39, SmallHarp, "Small Harp",
GI.GT_KLONDIKE, 1, -1,
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED,
altnames=("Die kleine Harfe",) ))
registerGame(GameInfo(66, Eastcliff, "Eastcliff",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(224, Easthaven, "Easthaven",
GI.GT_GYPSY, 1, 0))
GI.GT_GYPSY, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(33, Westcliff, "Westcliff",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(225, Westhaven, "Westhaven",
GI.GT_GYPSY, 1, 0))
GI.GT_GYPSY, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(107, PasSeul, "Pas Seul",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(81, BlindAlleys, "Blind Alleys",
GI.GT_KLONDIKE, 1, 1))
GI.GT_KLONDIKE, 1, 1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(215, Somerset, "Somerset",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(231, Canister, "Canister",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(229, AgnesSorel, "Agnes Sorel",
GI.GT_GYPSY, 1, 0))
GI.GT_GYPSY, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(4, EightTimesEight, "8 x 8",
GI.GT_KLONDIKE, 2, -1))
GI.GT_KLONDIKE, 2, -1, GI.SL_BALANCED))
registerGame(GameInfo(127, AchtmalAcht, "Eight Times Eight",
GI.GT_KLONDIKE, 2, 2,
GI.GT_KLONDIKE, 2, 2, GI.SL_BALANCED,
altnames=("Achtmal Acht",) ))
registerGame(GameInfo(133, Batsford, "Batsford",
GI.GT_KLONDIKE, 2, 0))
GI.GT_KLONDIKE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(221, Stonewall, "Stonewall",
GI.GT_RAGLAN, 1, 0))
GI.GT_RAGLAN, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(222, FlowerGarden, "Flower Garden",
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0,
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("The Bouquet", "The Garden",) ))
registerGame(GameInfo(233, KingAlbert, "King Albert",
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0,
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("Idiot's Delight",) ))
registerGame(GameInfo(232, Raglan, "Raglan",
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0))
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(223, Brigade, "Brigade",
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0))
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(230, Jane, "Jane",
GI.GT_RAGLAN, 1, 0))
GI.GT_RAGLAN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(236, AgnesBernauer, "Agnes Bernauer",
GI.GT_RAGLAN, 1, 0))
GI.GT_RAGLAN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(263, Phoenix, "Phoenix",
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0))
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(283, Jumbo, "Jumbo",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(333, OpenJumbo, "Open Jumbo",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(297, Alternation, "Alternation",
GI.GT_KLONDIKE, 2, 0))
GI.GT_KLONDIKE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(326, Lanes, "Lanes",
GI.GT_KLONDIKE, 1, 1))
GI.GT_KLONDIKE, 1, 1, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(327, ThirtySix, "Thirty Six",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(350, Q_C_, "Q.C.",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(361, NorthwestTerritory, "Northwest Territory",
GI.GT_RAGLAN, 1, 0))
GI.GT_RAGLAN, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(362, Morehead, "Morehead",
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0))
GI.GT_BELEAGUERED_CASTLE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(388, Senate, "Senate",
GI.GT_RAGLAN, 2, 0))
GI.GT_RAGLAN, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(389, SenatePlus, "Senate +",
GI.GT_RAGLAN, 2, 0))
GI.GT_RAGLAN, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(390, Arizona, "Arizona",
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0))
GI.GT_RAGLAN | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(407, AuntMary, "Aunt Mary",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(420, DoubleDot, "Double Dot",
GI.GT_KLONDIKE, 1, 0))
GI.GT_KLONDIKE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(434, SevenDevils, "Seven Devils",
GI.GT_RAGLAN, 2, 0))
GI.GT_RAGLAN, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(452, DoubleEasthaven, "Double Easthaven",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(453, TripleEasthaven, "Triple Easthaven",
GI.GT_GYPSY, 3, 0))
GI.GT_GYPSY, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(470, MovingLeft, "Moving Left",
GI.GT_KLONDIKE, 2, 0))
GI.GT_KLONDIKE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(471, Souter, "Souter",
GI.GT_KLONDIKE, 2, 1))
GI.GT_KLONDIKE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(473, BigForty, "Big Forty",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(474, AliBaba, "Ali Baba",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(475, Cassim, "Cassim",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(479, Saratoga, "Saratoga",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))
registerGame(GameInfo(491, Whitehorse, "Whitehorse",
GI.GT_KLONDIKE, 1, -1))
GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))

2
pysollib/games/mahjongg/mahjongg.py
View file

@ -708,7 +708,7 @@ def r(id, short_name, name=None, ncards=144, layout=None):
gameclass.NCARDS = ncards
decks, ranks, trumps = comp_cardset(ncards)
gi = GameInfo(id, gameclass, name,
GI.GT_MAHJONGG, 4*decks, 0,
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})

2
pysollib/games/mahjongg/shisensho.py
View file

@ -449,7 +449,7 @@ def r(id, gameclass, short_name, name=None, decks=1, ranks=10, trumps=12):
name = short_name
decks, ranks, trumps = comp_cardset(gameclass.NCARDS)
gi = GameInfo(id, gameclass, name,
GI.GT_SHISEN_SHO, 4*decks, 0,
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})

2
pysollib/games/matriarchy.py
View file

@ -225,5 +225,5 @@ class Matriarchy(Game):
# register the game
registerGame(GameInfo(17, Matriarchy, "Matriarchy",
GI.GT_2DECK_TYPE, 2, VARIABLE_REDEALS))
GI.GT_2DECK_TYPE, 2, VARIABLE_REDEALS, GI.SL_BALANCED))

16
pysollib/games/montana.py
View file

@ -385,23 +385,23 @@ class SpacesAndAces(BlueMoon):
# register the game
registerGame(GameInfo(53, Montana, "Montana",
GI.GT_MONTANA | GI.GT_OPEN, 1, 2,
GI.GT_MONTANA | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL,
si={"ncards": 48}, altnames="Gaps"))
registerGame(GameInfo(116, Spaces, "Spaces",
GI.GT_MONTANA | GI.GT_OPEN, 1, 2,
GI.GT_MONTANA | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL,
si={"ncards": 48}))
registerGame(GameInfo(63, BlueMoon, "Blue Moon",
GI.GT_MONTANA | GI.GT_OPEN, 1, 2,
GI.GT_MONTANA | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL,
altnames=("Rangoon",) ))
registerGame(GameInfo(117, RedMoon, "Red Moon",
GI.GT_MONTANA | GI.GT_OPEN, 1, 2))
GI.GT_MONTANA | GI.GT_OPEN, 1, 2, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(275, Galary, "Galary",
GI.GT_MONTANA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 2))
GI.GT_MONTANA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 2, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(276, Moonlight, "Moonlight",
GI.GT_MONTANA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 2,
GI.GT_MONTANA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 2, GI.SL_MOSTLY_SKILL,
si={"ncards": 48}))
registerGame(GameInfo(380, Jungle, "Jungle",
GI.GT_MONTANA | GI.GT_OPEN, 1, 1))
GI.GT_MONTANA | GI.GT_OPEN, 1, 1, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(381, SpacesAndAces, "Spaces and Aces",
GI.GT_MONTANA | GI.GT_OPEN, 1, 0))
GI.GT_MONTANA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))

24
pysollib/games/montecarlo.py
View file

@ -767,32 +767,32 @@ class DerLetzteMonarch(Game):
# register the game
registerGame(GameInfo(89, MonteCarlo, "Monte Carlo",
GI.GT_PAIRING_TYPE, 1, 0,
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK,
altnames=("Quilt",) ))
registerGame(GameInfo(216, Monaco, "Monaco",
GI.GT_PAIRING_TYPE, 2, 0))
GI.GT_PAIRING_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(212, Weddings, "Weddings",
GI.GT_PAIRING_TYPE, 1, 0))
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(90, SimpleCarlo, "Simple Carlo",
GI.GT_PAIRING_TYPE, 1, 0))
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(91, SimplePairs, "Simple Pairs",
GI.GT_PAIRING_TYPE, 1, 0,
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_LUCK,
altnames=("Jamestown",)))
registerGame(GameInfo(92, Neighbour, "Neighbour",
GI.GT_PAIRING_TYPE, 1, 0))
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(96, Fourteen, "Fourteen",
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(235, Nestor, "Nestor",
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(152, DerLetzteMonarch, "The last Monarch",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0,
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
altnames=("Der letzte Monarch",) ))
registerGame(GameInfo(328, TheWish, "The Wish",
GI.GT_PAIRING_TYPE, 1, 0,
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_MOSTLY_LUCK,
ranks=(0, 6, 7, 8, 9, 10, 11, 12) ))
registerGame(GameInfo(329, TheWishOpen, "The Wish (open)",
GI.GT_PAIRING_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0,
GI.GT_PAIRING_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL,
ranks=(0, 6, 7, 8, 9, 10, 11, 12) ))
registerGame(GameInfo(368, Vertical, "Vertical",
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_PAIRING_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_LUCK))

8
pysollib/games/napoleon.py
View file

@ -263,11 +263,11 @@ class FreeNapoleon(DerFreieNapoleon):
# register the game
registerGame(GameInfo(167, DerKleineNapoleon, "Der kleine Napoleon",
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0))
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(168, DerFreieNapoleon, "Der freie Napoleon",
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0))
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(169, Napoleon, "Napoleon",
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0))
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(170, FreeNapoleon, "Free Napoleon",
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0))
GI.GT_NAPOLEON | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))

6
pysollib/games/needle.py
View file

@ -113,9 +113,9 @@ class Pitchfork(Needle):
# register the game
registerGame(GameInfo(318, Needle, "Needle",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(319, Haystack, "Haystack",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(367, Pitchfork, "Pitchfork",
GI.GT_FREECELL | GI.GT_OPEN, 1, 0))
GI.GT_FREECELL | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))

22
pysollib/games/numerica.py
View file

@ -581,25 +581,25 @@ class Strategerie(Game):
# register the game
registerGame(GameInfo(257, Numerica, "Numerica",
GI.GT_NUMERICA | GI.GT_CONTRIB, 1, 0,
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.GT_NUMERICA, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(355, Frog, "Frog",
GI.GT_NUMERICA, 2, 0))
GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(356, Fly, "Fly",
GI.GT_NUMERICA, 2, 0))
GI.GT_NUMERICA, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(357, Gnat, "Gnat",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(378, Gloaming, "Gloaming",
GI.GT_NUMERICA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_NUMERICA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(379, Chamberlain, "Chamberlain",
GI.GT_NUMERICA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_NUMERICA | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(402, Toad, "Toad",
GI.GT_NUMERICA | GI.GT_ORIGINAL, 2, 0))
GI.GT_NUMERICA | GI.GT_ORIGINAL, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(430, PussInTheCorner, "Puss in the Corner",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(435, Shifting, "Shifting",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(472, Strategerie, "Strategerie",
GI.GT_NUMERICA, 1, 0))
GI.GT_NUMERICA, 1, 0, GI.SL_MOSTLY_SKILL))

12
pysollib/games/osmosis.py
View file

@ -287,16 +287,16 @@ class Bridesmaids(Game):
# register the game
registerGame(GameInfo(59, Osmosis, "Osmosis",
GI.GT_1DECK_TYPE, 1, -1,
GI.GT_1DECK_TYPE, 1, -1, GI.SL_MOSTLY_LUCK,
altnames=("Treasure Trove",) ))
registerGame(GameInfo(60, Peek, "Peek",
GI.GT_1DECK_TYPE, 1, -1))
GI.GT_1DECK_TYPE, 1, -1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(298, OpenPeek, "Open Peek",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(370, Genesis, "Genesis",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(371, GenesisPlus, "Genesis +",
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0))
GI.GT_1DECK_TYPE | GI.GT_OPEN | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(409, Bridesmaids, "Bridesmaids",
GI.GT_1DECK_TYPE, 1, -1))
GI.GT_1DECK_TYPE, 1, -1, GI.SL_MOSTLY_LUCK))

2
pysollib/games/parallels.py
View file

@ -168,7 +168,7 @@ class Parallels(Game):
# register the game
registerGame(GameInfo(428, Parallels, "Parallels",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

2
pysollib/games/pasdedeux.py
View file

@ -226,5 +226,5 @@ class PasDeDeux(Game):
# register the game
registerGame(GameInfo(153, PasDeDeux, "Pas de Deux",
GI.GT_MONTANA | GI.GT_SEPARATE_DECKS, 2, 1))
GI.GT_MONTANA | GI.GT_SEPARATE_DECKS, 2, 1, GI.SL_MOSTLY_SKILL))

8
pysollib/games/picturegallery.py
View file

@ -423,14 +423,14 @@ class Zeus(MountOlympus):
# register the game
registerGame(GameInfo(7, PictureGallery, "Picture Gallery",
GI.GT_2DECK_TYPE, 2, 0,
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.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED,
ranks=range(12) # without Kings
))
registerGame(GameInfo(398, MountOlympus, "Mount Olympus",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(399, Zeus, "Zeus",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

4
pysollib/games/pileon.py
View file

@ -128,10 +128,10 @@ class PileOn2Decks(PileOn):
# register the game
registerGame(GameInfo(41, PileOn, "PileOn",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0,
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.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(341, PileOn2Decks, "PileOn (2 decks)",

4
pysollib/games/poker.py
View file

@ -286,9 +286,9 @@ class PokerShuffle(PokerSquare):
# register the game
registerGame(GameInfo(139, PokerSquare, "Poker Square",
GI.GT_POKER_TYPE | GI.GT_SCORE, 1, 0,
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.GT_POKER_TYPE | GI.GT_SCORE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
si={"ncards": 25}))

4
pysollib/games/pushpin.py
View file

@ -224,8 +224,8 @@ class Queens(PushPin):
registerGame(GameInfo(287, PushPin, "Push Pin",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(288, RoyalMarriage, "Royal Marriage",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
## registerGame(GameInfo(303, Queens, "Queens",
## GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0))

4
pysollib/games/pyramid.py
View file

@ -293,9 +293,9 @@ class Thirteen(Pyramid):
# register the game
registerGame(GameInfo(38, Pyramid, "Pyramid",
GI.GT_PAIRING_TYPE, 1, 2))
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.GT_PAIRING_TYPE | GI.GT_RELAXED, 1, 2, GI.SL_MOSTLY_LUCK))
##registerGame(GameInfo(44, Thirteen, "Thirteen",
## GI.GT_PAIRING_TYPE, 1, 0))

18
pysollib/games/royalcotillion.py
View file

@ -526,25 +526,25 @@ class Twenty(Game):
# register the game
registerGame(GameInfo(54, RoyalCotillion, "Royal Cotillion",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_LUCK))
registerGame(GameInfo(55, OddAndEven, "Odd and Even",
GI.GT_2DECK_TYPE, 2, 1))
GI.GT_2DECK_TYPE, 2, 1, GI.SL_LUCK))
registerGame(GameInfo(143, Kingdom, "Kingdom",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(234, Alhambra, "Alhambra",
GI.GT_2DECK_TYPE, 2, 2))
GI.GT_2DECK_TYPE, 2, 2, GI.SL_BALANCED))
registerGame(GameInfo(97, Carpet, "Carpet",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(391, BritishConstitution, "British Constitution",
GI.GT_2DECK_TYPE, 2, 0,
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED,
ranks=range(11) # without Queens and Kings
))
registerGame(GameInfo(392, NewBritishConstitution, "New British Constitution",
GI.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0,
GI.GT_2DECK_TYPE | GI.GT_ORIGINAL, 2, 0, GI.SL_BALANCED,
ranks=range(11) # without Queens and Kings
))
registerGame(GameInfo(443, Twenty, "Twenty",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(465, Granada, "Granada",
GI.GT_2DECK_TYPE, 2, 2))
GI.GT_2DECK_TYPE, 2, 2, GI.SL_BALANCED))

2
pysollib/games/royaleast.py
View file

@ -119,5 +119,5 @@ class RoyalEast(Game):
# register the game
registerGame(GameInfo(93, RoyalEast, "Royal East",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))

4
pysollib/games/siebenbisas.py
View file

@ -260,9 +260,9 @@ class Maze(Game):
# register the game
registerGame(GameInfo(118, SiebenBisAs, "Sieben bis As",
GI.GT_MONTANA | GI.GT_OPEN, 1, 0,
GI.GT_MONTANA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
ranks=(0, 6, 7, 8, 9, 10, 11, 12)))
registerGame(GameInfo(144, Maze, "Maze",
GI.GT_MONTANA | GI.GT_OPEN, 1, 0,
GI.GT_MONTANA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL,
si={"ncards": 48}))

2
pysollib/games/simplex.py
View file

@ -100,4 +100,4 @@ class Simplex(Game):
# register the game
registerGame(GameInfo(436, Simplex, "Simplex",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))

8
pysollib/games/special/hanoi.py
View file

@ -148,18 +148,18 @@ class HanoiPuzzle6(HanoiPuzzle4):
# register the game
registerGame(GameInfo(124, TowerOfHanoy, "Tower of Hanoy",
GI.GT_PUZZLE_TYPE, 1, 0,
GI.GT_PUZZLE_TYPE, 1, 0, GI.SL_SKILL,
suits=(2,), ranks=range(9)))
registerGame(GameInfo(207, HanoiPuzzle4, "Hanoi Puzzle 4",
GI.GT_PUZZLE_TYPE, 1, 0,
GI.GT_PUZZLE_TYPE, 1, 0, GI.SL_SKILL,
suits=(2,), ranks=range(4),
rules_filename="hanoipuzzle.html"))
registerGame(GameInfo(208, HanoiPuzzle5, "Hanoi Puzzle 5",
GI.GT_PUZZLE_TYPE, 1, 0,
GI.GT_PUZZLE_TYPE, 1, 0, GI.SL_SKILL,
suits=(2,), ranks=range(5),
rules_filename="hanoipuzzle.html"))
registerGame(GameInfo(209, HanoiPuzzle6, "Hanoi Puzzle 6",
GI.GT_PUZZLE_TYPE, 1, 0,
GI.GT_PUZZLE_TYPE, 1, 0, GI.SL_SKILL,
suits=(2,), ranks=range(6),
rules_filename="hanoipuzzle.html"))

8
pysollib/games/special/memory.py
View file

@ -311,14 +311,14 @@ class Concentration(Memory24):
# register the game
registerGame(GameInfo(176, Memory24, "Memory 24",
GI.GT_MEMORY | GI.GT_SCORE, 2, 0,
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.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL,
suits=(0,2,3), ranks=(0,9,10,11,12)))
registerGame(GameInfo(177, Memory40, "Memory 40",
GI.GT_MEMORY | GI.GT_SCORE, 2, 0,
GI.GT_MEMORY | GI.GT_SCORE, 2, 0, GI.SL_SKILL,
suits=(0,2), ranks=(0,4,5,6,7,8,9,10,11,12)))
registerGame(GameInfo(178, Concentration, "Concentration",
GI.GT_MEMORY | GI.GT_SCORE, 1, 0))
GI.GT_MEMORY | GI.GT_SCORE, 1, 0, GI.SL_SKILL))

2
pysollib/games/special/pegged.py
View file

@ -244,7 +244,7 @@ def r(id, gameclass, name):
for n in gameclass.ROWS:
si_ncards = si_ncards + n
gi = GameInfo(id, gameclass, name,
GI.GT_PUZZLE_TYPE, 1, 0,
GI.GT_PUZZLE_TYPE, 1, 0, GI.SL_SKILL,
si={"ncards": si_ncards},
rules_filename = "pegged.html")
registerGame(gi)

31
pysollib/games/special/tarock.py
View file

@ -516,6 +516,7 @@ class Skiz(AbstractTarockGame):
# ************************************************************************/
class FifteenPlus(AbstractTarockGame):
Hint_Class = CautiousDefaultHint
#
# Game layout
@ -918,26 +919,26 @@ class Nasty(Wicked):
# // register the games
# ************************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
ranks=range(14), trumps=range(22))
registerGame(gi)
return gi
r(157, WheelOfFortune, "Wheel of Fortune", GI.GT_TAROCK, 1, 0)
r(158, ImperialTrumps, "Imperial Trumps", GI.GT_TAROCK, 1, -1)
r(159, Pagat, "Pagat", GI.GT_TAROCK | GI.GT_OPEN, 1, 0)
r(160, Skiz, "Skiz", GI.GT_TAROCK | GI.GT_OPEN, 1, 0)
r(161, FifteenPlus, "Fifteen plus", GI.GT_TAROCK, 1, 0)
r(162, Excuse, "Excuse", GI.GT_TAROCK | GI.GT_OPEN, 1, 0)
r(163, Grasshopper, "Grasshopper", GI.GT_TAROCK, 1, 1)
r(164, DoubleGrasshopper, "Double Grasshopper", GI.GT_TAROCK, 2, 1)
r(179, Ponytail, "Ponytail", GI.GT_TAROCK, 2, 2)
r(202, Cavalier, "Cavalier", GI.GT_TAROCK, 1, 0)
r(203, FiveAces, "Five Aces", GI.GT_TAROCK, 1, 0)
r(204, Wicked, "Wicked", GI.GT_TAROCK | GI.GT_OPEN, 1, -1)
r(205, Nasty, "Nasty", GI.GT_TAROCK | GI.GT_OPEN, 1, -1)
r(157, WheelOfFortune, "Wheel of Fortune", GI.GT_TAROCK, 1, 0, GI.SL_BALANCED)
r(158, ImperialTrumps, "Imperial Trumps", GI.GT_TAROCK, 1, -1, GI.SL_BALANCED)
r(159, Pagat, "Pagat", GI.GT_TAROCK | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(160, Skiz, "Skiz", GI.GT_TAROCK | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(161, FifteenPlus, "Fifteen plus", GI.GT_TAROCK, 1, 0, GI.SL_BALANCED)
r(162, Excuse, "Excuse", GI.GT_TAROCK | GI.GT_OPEN, 1, 0, GI.SL_BALANCED)
r(163, Grasshopper, "Grasshopper", GI.GT_TAROCK, 1, 1, GI.SL_MOSTLY_SKILL)
r(164, DoubleGrasshopper, "Double Grasshopper", GI.GT_TAROCK, 2, 1, GI.SL_MOSTLY_SKILL)
r(179, Ponytail, "Ponytail", GI.GT_TAROCK, 2, 2, GI.SL_MOSTLY_SKILL)
r(202, Cavalier, "Cavalier", GI.GT_TAROCK, 1, 0, GI.SL_MOSTLY_SKILL)
r(203, FiveAces, "Five Aces", GI.GT_TAROCK, 1, 0, GI.SL_MOSTLY_SKILL)
r(204, Wicked, "Wicked", GI.GT_TAROCK | GI.GT_OPEN, 1, -1, GI.SL_BALANCED)
r(205, Nasty, "Nasty", GI.GT_TAROCK | GI.GT_OPEN, 1, -1, GI.SL_BALANCED)
del r

82
pysollib/games/spider.py
View file

@ -986,98 +986,98 @@ class FredsSpider3Decks(FredsSpider):
# register the game
registerGame(GameInfo(10, RelaxedSpider, "Relaxed Spider",
GI.GT_SPIDER | GI.GT_RELAXED, 2, 0))
GI.GT_SPIDER | GI.GT_RELAXED, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(11, Spider, "Spider",
GI.GT_SPIDER, 2, 0,
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=("Tarantula",) ))
registerGame(GameInfo(49, BlackWidow, "Black Widow",
GI.GT_SPIDER, 2, 0,
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=("Scarab",) ))
registerGame(GameInfo(14, GroundForADivorce, "Ground for a Divorce",
GI.GT_SPIDER, 2, 0,
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=('Scheidungsgrund',) ))
registerGame(GameInfo(114, GrandmothersGame, "Grandmother's Game",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(24, Spiderette, "Spiderette",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(47, BabySpiderette, "Baby Spiderette",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(48, WillOTheWisp, "Will o' the Wisp",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(50, SimpleSimon, "Simple Simon",
GI.GT_SPIDER | GI.GT_OPEN, 1, 0))
GI.GT_SPIDER | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(194, Rachel, "Rachel",
GI.GT_SPIDER | GI.GT_XORIGINAL, 1, 0))
GI.GT_SPIDER | GI.GT_XORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(29, Scorpion, "Scorpion",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(185, Wasp, "Wasp",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(220, RougeEtNoir, "Rouge et Noir",
GI.GT_GYPSY, 2, 0))
GI.GT_GYPSY, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(269, Spider1Suit, "Spider (1 suit)",
GI.GT_SPIDER, 2, 0,
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
suits=(0, 0, 0, 0),
rules_filename="spider.html"))
registerGame(GameInfo(270, Spider2Suits, "Spider (2 suits)",
GI.GT_SPIDER, 2, 0,
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL,
suits=(0, 0, 2, 2),
rules_filename="spider.html"))
registerGame(GameInfo(305, ThreeBlindMice, "Three Blind Mice",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(309, MrsMop, "Mrs. Mop",
GI.GT_SPIDER | GI.GT_OPEN, 2, 0))
GI.GT_SPIDER | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(341, Cicely, "Cicely",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(342, Trillium, "Trillium",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(343, Lily, "Lily",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(344, Chelicera, "Chelicera",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(345, ScorpionHead, "Scorpion Head",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(346, ScorpionTail, "Scorpion Tail",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(359, SpiderWeb, "Spider Web",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(366, SimonJester, "Simon Jester",
GI.GT_SPIDER | GI.GT_OPEN, 2, 0))
GI.GT_SPIDER | GI.GT_OPEN, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(382, Applegate, "Applegate",
GI.GT_SPIDER, 1, 0))
GI.GT_SPIDER, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(384, BigSpider, "Big Spider",
GI.GT_SPIDER, 3, 0))
GI.GT_SPIDER, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(401, GroundForADivorce3Decks, "Big Ground",
GI.GT_SPIDER, 3, 0))
GI.GT_SPIDER, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(441, York, "York",
GI.GT_SPIDER | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0))
GI.GT_SPIDER | GI.GT_OPEN | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(444, TripleYork, "Triple York",
GI.GT_SPIDER | GI.GT_OPEN | GI.GT_ORIGINAL, 3, 0))
GI.GT_SPIDER | GI.GT_OPEN | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(445, BigSpider1Suit, "Big Spider (1 suit)",
GI.GT_SPIDER, 3, 0,
GI.GT_SPIDER, 3, 0, GI.SL_MOSTLY_SKILL,
suits=(0, 0, 0, 0),
rules_filename="bigspider.html"))
registerGame(GameInfo(446, BigSpider2Suits, "Big Spider (2 suits)",
GI.GT_SPIDER, 3, 0,
GI.GT_SPIDER, 3, 0, GI.SL_MOSTLY_SKILL,
suits=(0, 0, 2, 2),
rules_filename="bigspider.html"))
registerGame(GameInfo(449, Spider3x3, "Spider 3x3",
GI.GT_SPIDER | GI.GT_ORIGINAL, 3, 0,
GI.GT_SPIDER | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL,
suits=(0, 1, 2),
rules_filename="bigspider.html"))
registerGame(GameInfo(454, Spider4Decks, "Spider (4 decks)",
GI.GT_SPIDER, 4, 0))
GI.GT_SPIDER, 4, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(455, GroundForADivorce4Decks, "Very Big Ground",
GI.GT_SPIDER, 4, 0))
GI.GT_SPIDER, 4, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(458, Spidike, "Spidike",
GI.GT_SPIDER, 1, 0)) # GT_GYPSY ?
GI.GT_SPIDER, 1, 0, GI.SL_BALANCED)) # GT_GYPSY ?
registerGame(GameInfo(459, FredsSpider, "Fred's Spider",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(460, FredsSpider3Decks, "Fred's Spider (3 decks)",
GI.GT_SPIDER, 3, 0))
GI.GT_SPIDER, 3, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(461, OpenSpider, "Open Spider",
GI.GT_SPIDER, 2, 0))
GI.GT_SPIDER, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(501, WakeRobin, "Wake-Robin",
GI.GT_SPIDER | GI.GT_ORIGINAL, 2, 0))
GI.GT_SPIDER | GI.GT_ORIGINAL, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(502, TripleWakeRobin, "Wake-Robin (3 decks)",
GI.GT_SPIDER | GI.GT_ORIGINAL, 3, 0))
GI.GT_SPIDER | GI.GT_ORIGINAL, 3, 0, GI.SL_MOSTLY_SKILL))

4
pysollib/games/sthelena.py
View file

@ -167,10 +167,10 @@ class BoxKite(StHelena):
# register the game
registerGame(GameInfo(302, StHelena, "St. Helena",
GI.GT_2DECK_TYPE, 2, 2,
GI.GT_2DECK_TYPE, 2, 2, GI.SL_BALANCED,
altnames=("Napoleon's Favorite",
"Washington's Favorite")
))
registerGame(GameInfo(408, BoxKite, "Box Kite",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

24
pysollib/games/sultan.py
View file

@ -688,27 +688,27 @@ class CornerSuite(Game):
# register the game
registerGame(GameInfo(330, Sultan, "Sultan",
GI.GT_2DECK_TYPE, 2, 2,
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.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(354, Boudoir, "Boudoir",
GI.GT_2DECK_TYPE, 2, 2))
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(410, CaptiveQueens, "Captive Queens",
GI.GT_1DECK_TYPE, 1, 2))
GI.GT_1DECK_TYPE, 1, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(418, Contradance, "Contradance",
GI.GT_2DECK_TYPE, 2, 1))
GI.GT_2DECK_TYPE, 2, 1, GI.SL_LUCK))
registerGame(GameInfo(419, IdleAces, "Idle Aces",
GI.GT_2DECK_TYPE, 2, 2))
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.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(424, Matrimony, "Matrimony",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(429, Patriarchs, "Patriarchs",
GI.GT_2DECK_TYPE, 2, 1))
GI.GT_2DECK_TYPE, 2, 1, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(437, Simplicity, "Simplicity",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(438, SixesAndSevens, "Sixes and Sevens",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(477, CornerSuite, "Corner Suite",
GI.GT_2DECK_TYPE, 1, 0))
GI.GT_2DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))

4
pysollib/games/takeaway.py
View file

@ -104,9 +104,9 @@ class FourStacks(TakeAway):
# register the game
registerGame(GameInfo(334, TakeAway, "Take Away",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(335, FourStacks, "Four Stacks",
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0))
GI.GT_1DECK_TYPE | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL))

14
pysollib/games/terrace.py
View file

@ -291,17 +291,17 @@ class Madame(Terrace):
# register the game
registerGame(GameInfo(135, Terrace, "Terrace",
GI.GT_TERRACE, 2, 0))
GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(136, GeneralsPatience, "General's Patience",
GI.GT_TERRACE, 2, 0))
GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(137, BlondesAndBrunettes, "Blondes and Brunettes",
GI.GT_TERRACE, 2, 0))
GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(138, FallingStar, "Falling Star",
GI.GT_TERRACE, 2, 0))
GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(431, QueenOfItaly, "Queen of Italy",
GI.GT_TERRACE, 2, 0))
GI.GT_TERRACE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(499, Signora, "Signora",
GI.GT_TERRACE, 2, 0))
GI.GT_TERRACE, 2, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(500, Madame, "Madame",
GI.GT_TERRACE, 3, 0))
GI.GT_TERRACE, 3, 0, GI.SL_MOSTLY_SKILL))

6
pysollib/games/tournament.py
View file

@ -235,13 +235,13 @@ class KingsdownEights(Game):
# register the game
registerGame(GameInfo(303, Tournament, "Tournament",
GI.GT_2DECK_TYPE, 2, 2))
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(304, LaNivernaise, "La Nivernaise",
GI.GT_2DECK_TYPE, 2, 2,
GI.GT_2DECK_TYPE, 2, 2, GI.SL_MOSTLY_LUCK,
altnames = ("Napoleon's Flank", ),
rules_filename = "tournament.html"))
registerGame(GameInfo(386, KingsdownEights, "Kingsdown Eights",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

40
pysollib/games/ultra/dashavatara.py
View file

@ -1266,29 +1266,29 @@ class Dashavatara(Game):
# *
# ***********************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
suits=range(10), ranks=range(12))
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
suits=range(10), ranks=range(12))
registerGame(gi)
return gi
r(15406, Matsya, "Matsya", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15407, Kurma, "Kurma", GI.GT_DASHAVATARA_GANJIFA, 1, -1)
r(15408, Varaha, "Varaha", GI.GT_DASHAVATARA_GANJIFA, 1, -1)
r(15409, Narasimha, "Narasimha", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15410, Vamana, "Vamana", GI.GT_DASHAVATARA_GANJIFA, 1, -1)
r(15411, Parashurama, "Parashurama", GI.GT_DASHAVATARA_GANJIFA, 1, 1)
r(15412, TenAvatars, "Ten Avatars", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15413, DashavataraCircles, "Dashavatara Circles", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15414, Balarama, "Balarama", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15415, Hayagriva, "Hayagriva", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15416, Shanka, "Shanka", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15417, Journey, "Journey to Cuddapah", GI.GT_DASHAVATARA_GANJIFA, 1, 2)
r(15418, LongJourney, "Long Journey to Cuddapah", GI.GT_DASHAVATARA_GANJIFA, 2, 2)
r(15419, Surukh, "Surukh", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15420, AppachansWaterfall, "Appachan's Waterfall", GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15421, Hiranyaksha, 'Hiranyaksha', GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15422, Dashavatara, 'Dashavatara', GI.GT_DASHAVATARA_GANJIFA, 1, 0)
r(15406, Matsya, "Matsya", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_BALANCED)
r(15407, Kurma, "Kurma", GI.GT_DASHAVATARA_GANJIFA, 1, -1, GI.SL_BALANCED)
r(15408, Varaha, "Varaha", GI.GT_DASHAVATARA_GANJIFA, 1, -1, GI.SL_BALANCED)
r(15409, Narasimha, "Narasimha", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_BALANCED)
r(15410, Vamana, "Vamana", GI.GT_DASHAVATARA_GANJIFA, 1, -1, GI.SL_BALANCED)
r(15411, Parashurama, "Parashurama", GI.GT_DASHAVATARA_GANJIFA, 1, 1, GI.SL_BALANCED)
r(15412, TenAvatars, "Ten Avatars", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15413, DashavataraCircles, "Dashavatara Circles", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15414, Balarama, "Balarama", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15415, Hayagriva, "Hayagriva", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15416, Shanka, "Shanka", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15417, Journey, "Journey to Cuddapah", GI.GT_DASHAVATARA_GANJIFA, 1, 2, GI.SL_BALANCED)
r(15418, LongJourney, "Long Journey to Cuddapah", GI.GT_DASHAVATARA_GANJIFA, 2, 2, GI.SL_BALANCED)
r(15419, Surukh, "Surukh", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_BALANCED)
r(15420, AppachansWaterfall, "Appachan's Waterfall", GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15421, Hiranyaksha, 'Hiranyaksha', GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(15422, Dashavatara, 'Dashavatara', GI.GT_DASHAVATARA_GANJIFA, 1, 0, GI.SL_BALANCED)
del r

56
pysollib/games/ultra/hanafuda.py
View file

@ -1015,38 +1015,38 @@ class Paulownia(AbstractFlowerGame):
# // Register the games
# ************************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
suits=range(12), ranks=range(4))
registerGame(gi)
return gi
r(12345, Oonsoo, "Oonsoo", GI.GT_HANAFUDA, 1, 0)
r(12346, MatsuKiri, "MatsuKiri", GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12372, MatsuKiriStrict, 'MatsuKiri Strict', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12347, Gaji, "Gaji", GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12348, FlowerClock, "Flower Clock", GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12349, Pagoda, "Pagoda", GI.GT_HANAFUDA, 2, 0)
r(12350, Samuri, "Samuri", GI.GT_HANAFUDA, 1, 0)
r(12351, GreatWall, "Great Wall", GI.GT_HANAFUDA, 4, 0)
r(12352, FourWinds, "Four Winds", GI.GT_HANAFUDA, 1, 1)
r(12353, Sumo, "Sumo", GI.GT_HANAFUDA, 1, 0)
r(12354, BigSumo, "Big Sumo", GI.GT_HANAFUDA, 2, 0)
r(12355, LittleEasy, "Little Easy", GI.GT_HANAFUDA, 1, -1)
r(12356, BigEasy, "Big Easy", GI.GT_HANAFUDA, 2, -1)
r(12357, EasySupreme, "Easy Supreme", GI.GT_HANAFUDA, 4, -1)
r(12358, JustForFun, "Just For Fun", GI.GT_HANAFUDA, 1, 0)
r(12359, Firecracker, "Firecracker", GI.GT_HANAFUDA, 1, 0)
r(12360, EasyX1, "Easy x One", GI.GT_HANAFUDA, 1, 1)
r(12361, Relax, "Relax", GI.GT_HANAFUDA, 1, 1)
r(12362, DoubleSamuri, "Double Samuri", GI.GT_HANAFUDA, 2, 0)
r(12363, SuperSamuri, "Super Samuri", GI.GT_HANAFUDA, 4, 0)
r(12364, DoubleYourFun, "Double Your Fun", GI.GT_HANAFUDA, 2, 0)
r(12365, CherryBomb, "Cherry Bomb", GI.GT_HANAFUDA, 2, 0)
r(12366, OonsooToo, "Oonsoo Too", GI.GT_HANAFUDA, 1, 0)
r(12367, OonsooStrict, "Oonsoo Strict", GI.GT_HANAFUDA, 1, 0)
r(12368, OonsooOpen, "Oonsoo Open", GI.GT_HANAFUDA, 1, 0)
r(12379, OonsooTimesTwo, "Oonsoo Times Two", GI.GT_HANAFUDA, 2, 0)
r(12345, Oonsoo, "Oonsoo", GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12346, MatsuKiri, "MatsuKiri", GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12372, MatsuKiriStrict, 'MatsuKiri Strict', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12347, Gaji, "Gaji", GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12348, FlowerClock, "Flower Clock", GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12349, Pagoda, "Pagoda", GI.GT_HANAFUDA, 2, 0, GI.SL_BALANCED)
r(12350, Samuri, "Samuri", GI.GT_HANAFUDA, 1, 0, GI.SL_BALANCED)
r(12351, GreatWall, "Great Wall", GI.GT_HANAFUDA, 4, 0, GI.SL_MOSTLY_SKILL)
r(12352, FourWinds, "Four Winds", GI.GT_HANAFUDA, 1, 1, GI.SL_MOSTLY_SKILL)
r(12353, Sumo, "Sumo", GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12354, BigSumo, "Big Sumo", GI.GT_HANAFUDA, 2, 0, GI.SL_MOSTLY_SKILL)
r(12355, LittleEasy, "Little Easy", GI.GT_HANAFUDA, 1, -1, GI.SL_BALANCED)
r(12356, BigEasy, "Big Easy", GI.GT_HANAFUDA, 2, -1, GI.SL_BALANCED)
r(12357, EasySupreme, "Easy Supreme", GI.GT_HANAFUDA, 4, -1, GI.SL_BALANCED)
r(12358, JustForFun, "Just For Fun", GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12359, Firecracker, "Firecracker", GI.GT_HANAFUDA, 1, 0, GI.SL_BALANCED)
r(12360, EasyX1, "Easy x One", GI.GT_HANAFUDA, 1, 1, GI.SL_BALANCED)
r(12361, Relax, "Relax", GI.GT_HANAFUDA, 1, 1, GI.SL_BALANCED)
r(12362, DoubleSamuri, "Double Samuri", GI.GT_HANAFUDA, 2, 0, GI.SL_BALANCED)
r(12363, SuperSamuri, "Super Samuri", GI.GT_HANAFUDA, 4, 0, GI.SL_BALANCED)
r(12364, DoubleYourFun, "Double Your Fun", GI.GT_HANAFUDA, 2, 0, GI.SL_MOSTLY_SKILL)
r(12365, CherryBomb, "Cherry Bomb", GI.GT_HANAFUDA, 2, 0, GI.SL_BALANCED)
r(12366, OonsooToo, "Oonsoo Too", GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12367, OonsooStrict, "Oonsoo Strict", GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12368, OonsooOpen, "Oonsoo Open", GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12379, OonsooTimesTwo, "Oonsoo Times Two", GI.GT_HANAFUDA, 2, 0, GI.SL_MOSTLY_SKILL)
del r

34
pysollib/games/ultra/hanafuda1.py
View file

@ -691,27 +691,27 @@ class FlowerArrangement(Game):
# * Register the games
# ************************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
suits=range(12), ranks=range(4))
registerGame(gi)
return gi
r(12369, Paulownia, 'Paulownia', GI.GT_HANAFUDA, 1, -1)
r(12370, LesserQueue, 'Lesser Queue', GI.GT_HANAFUDA, 2, 2)
r(12371, GreaterQueue, 'Greater Queue', GI.GT_HANAFUDA, 4, 2)
r(12373, JapaneseGarden, 'Japanese Garden', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12374, JapaneseGardenII, 'Japanese Garden II', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12375, SixSages, 'Six Sages', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12376, SixTengus, 'Six Tengus', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12377, JapaneseGardenIII, 'Japanese Garden III', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12378, HanafudaFourSeasons, 'Hanafuda Four Seasons', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0)
r(12380, Eularia, 'Eularia', GI.GT_HANAFUDA, 1, -1)
r(12381, Peony, 'Peony', GI.GT_HANAFUDA, 1, -1)
r(12382, Iris, 'Iris', GI.GT_HANAFUDA, 1, 0)
r(12383, Pine, 'Pine', GI.GT_HANAFUDA, 1, 0)
r(12384, Wisteria, 'Wisteria', GI.GT_HANAFUDA, 1, 0)
r(12385, FlowerArrangement, 'Flower Arrangement', GI.GT_HANAFUDA, 2, 0)
r(12369, Paulownia, 'Paulownia', GI.GT_HANAFUDA, 1, -1, GI.SL_BALANCED)
r(12370, LesserQueue, 'Lesser Queue', GI.GT_HANAFUDA, 2, 2, GI.SL_BALANCED)
r(12371, GreaterQueue, 'Greater Queue', GI.GT_HANAFUDA, 4, 2, GI.SL_BALANCED)
r(12373, JapaneseGarden, 'Japanese Garden', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12374, JapaneseGardenII, 'Japanese Garden II', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12375, SixSages, 'Six Sages', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12376, SixTengus, 'Six Tengus', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12377, JapaneseGardenIII, 'Japanese Garden III', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12378, HanafudaFourSeasons, 'Hanafuda Four Seasons', GI.GT_HANAFUDA | GI.GT_OPEN, 1, 0, GI.SL_MOSTLY_SKILL)
r(12380, Eularia, 'Eularia', GI.GT_HANAFUDA, 1, -1, GI.SL_BALANCED)
r(12381, Peony, 'Peony', GI.GT_HANAFUDA, 1, -1, GI.SL_BALANCED)
r(12382, Iris, 'Iris', GI.GT_HANAFUDA, 1, 0, GI.SL_BALANCED)
r(12383, Pine, 'Pine', GI.GT_HANAFUDA, 1, 0, GI.SL_BALANCED)
r(12384, Wisteria, 'Wisteria', GI.GT_HANAFUDA, 1, 0, GI.SL_MOSTLY_SKILL)
r(12385, FlowerArrangement, 'Flower Arrangement', GI.GT_HANAFUDA, 2, 0, GI.SL_BALANCED)
del r

40
pysollib/games/ultra/hexadeck.py
View file

@ -1376,30 +1376,30 @@ class Snakestone(Convolution):
# //
# ************************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
suits=range(4), ranks=range(16), trumps=range(4))
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
suits=range(4), ranks=range(16), trumps=range(4))
registerGame(gi)
return gi
r(165, BitsNBytes, 'Bits n Bytes', GI.GT_HEXADECK, 1, 1)
r(166, HexAKlon, 'Hex A Klon', GI.GT_HEXADECK, 1, -1)
r(16666, KlondikePlus16, 'Klondike Plus 16', GI.GT_HEXADECK, 1, 1)
r(16667, HexAKlonByThrees, 'Hex A Klon by Threes', GI.GT_HEXADECK, 1, -1)
r(16668, KingOnlyHexAKlon, 'King Only Hex A Klon', GI.GT_HEXADECK, 1, -1)
r(16669, TheFamiliar, 'The Familiar', GI.GT_HEXADECK, 1, 1)
r(16670, TwoFamiliars, 'Two Familiars', GI.GT_HEXADECK, 2, 1)
r(16671, TenByEight, '10 x 8', GI.GT_HEXADECK, 2, -1)
r(16672, Drawbridge, 'Drawbridge', GI.GT_HEXADECK, 1, 1)
r(16673, DoubleDrawbridge, 'Double Drawbridge', GI.GT_HEXADECK, 2, 1)
r(16674, HiddenPassages, 'Hidden Passages', GI.GT_HEXADECK, 1, 1)
r(16675, CluitjarsLair, 'Cluitjar\'s Lair', GI.GT_HEXADECK, 1, 0)
r(16676, MerlinsMeander, 'Merlin\'s Meander', GI.GT_HEXADECK, 2, 2)
r(16677, MagesGame, 'Mage\'s Game', GI.GT_HEXADECK, 1, 0)
r(16678, Convolution, 'Convolution', GI.GT_HEXADECK, 2, 0)
r(16679, Labyrinth, 'Hex Labyrinth', GI.GT_HEXADECK, 2, 0)
r(16680, Snakestone, 'Snakestone', GI.GT_HEXADECK, 2, 0)
r(165, BitsNBytes, 'Bits n Bytes', GI.GT_HEXADECK, 1, 1, GI.SL_BALANCED)
r(166, HexAKlon, 'Hex A Klon', GI.GT_HEXADECK, 1, -1, GI.SL_BALANCED)
r(16666, KlondikePlus16, 'Klondike Plus 16', GI.GT_HEXADECK, 1, 1, GI.SL_BALANCED)
r(16667, HexAKlonByThrees, 'Hex A Klon by Threes', GI.GT_HEXADECK, 1, -1, GI.SL_BALANCED)
r(16668, KingOnlyHexAKlon, 'King Only Hex A Klon', GI.GT_HEXADECK, 1, -1, GI.SL_BALANCED)
r(16669, TheFamiliar, 'The Familiar', GI.GT_HEXADECK, 1, 1, GI.SL_BALANCED)
r(16670, TwoFamiliars, 'Two Familiars', GI.GT_HEXADECK, 2, 1, GI.SL_BALANCED)
r(16671, TenByEight, '10 x 8', GI.GT_HEXADECK, 2, -1, GI.SL_BALANCED)
r(16672, Drawbridge, 'Drawbridge', GI.GT_HEXADECK, 1, 1, GI.SL_BALANCED)
r(16673, DoubleDrawbridge, 'Double Drawbridge', GI.GT_HEXADECK, 2, 1, GI.SL_BALANCED)
r(16674, HiddenPassages, 'Hidden Passages', GI.GT_HEXADECK, 1, 1, GI.SL_MOSTLY_LUCK)
r(16675, CluitjarsLair, 'Cluitjar\'s Lair', GI.GT_HEXADECK, 1, 0, GI.SL_BALANCED)
r(16676, MerlinsMeander, 'Merlin\'s Meander', GI.GT_HEXADECK, 2, 2, GI.SL_BALANCED)
r(16677, MagesGame, 'Mage\'s Game', GI.GT_HEXADECK, 1, 0, GI.SL_BALANCED)
r(16678, Convolution, 'Convolution', GI.GT_HEXADECK, 2, 0, GI.SL_MOSTLY_SKILL)
r(16679, Labyrinth, 'Hex Labyrinth', GI.GT_HEXADECK, 2, 0, GI.SL_MOSTLY_SKILL)
r(16680, Snakestone, 'Snakestone', GI.GT_HEXADECK, 2, 0, GI.SL_MOSTLY_SKILL)
del r

31
pysollib/games/ultra/larasgame.py
View file

@ -717,58 +717,59 @@ class DoubleDojoujisGame(DojoujisGame):
# register the game
registerGame(GameInfo(37, LarasGame, "Lara's Game", GI.GT_2DECK_TYPE, 2, 0))
registerGame(GameInfo(37, LarasGame, "Lara's Game",
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(13001, KatrinasGame, "Katrina's Game",
GI.GT_TAROCK, 2, 1,
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.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.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.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.GT_HANAFUDA, 2, 0, GI.SL_BALANCED,
suits = range(12), ranks = range(4)))
registerGame(GameInfo(13006, RelaxedLarasGame, "Lara's Game Relaxed",
GI.GT_2DECK_TYPE, 2, 1))
GI.GT_2DECK_TYPE, 2, 1, GI.SL_BALANCED))
registerGame(GameInfo(13007, DoubleLarasGame, "Lara's Game Doubled",
GI.GT_2DECK_TYPE, 4, 2))
GI.GT_2DECK_TYPE, 4, 2, GI.SL_BALANCED))
registerGame(GameInfo(13008, RelaxedKatrinasGame, "Katrina's Game Relaxed",
GI.GT_TAROCK, 2, 1,
GI.GT_TAROCK, 2, 1, GI.SL_BALANCED,
ranks = range(14), trumps = range(22)))
registerGame(GameInfo(13009, DoubleKatrinasGame, "Katrina's Game Doubled",
GI.GT_TAROCK, 4, 2,
GI.GT_TAROCK, 4, 2, GI.SL_BALANCED,
ranks = range(14), trumps = range(22)))
registerGame(GameInfo(13010, DoubleBridgetsGame, "Bridget's Game Doubled",
GI.GT_HEXADECK, 4, 2,
GI.GT_HEXADECK, 4, 2, GI.SL_BALANCED,
ranks = range(16), trumps = range(4)))
registerGame(GameInfo(13011, RelaxedKalisGame, "Kali's Game Relaxed",
GI.GT_DASHAVATARA_GANJIFA, 1, 2,
GI.GT_DASHAVATARA_GANJIFA, 1, 2, GI.SL_BALANCED,
suits = range(10), ranks = range(12)))
registerGame(GameInfo(13012, DoubleKalisGame, "Kali's Game Doubled",
GI.GT_DASHAVATARA_GANJIFA, 2, 3,
GI.GT_DASHAVATARA_GANJIFA, 2, 3, GI.SL_BALANCED,
suits = range(10), ranks = range(12)))
registerGame(GameInfo(13013, RelaxedFatimehsGame, "Fatimeh's Game Relaxed",
GI.GT_MUGHAL_GANJIFA, 1, 2,
GI.GT_MUGHAL_GANJIFA, 1, 2, GI.SL_BALANCED,
suits = range(8), ranks = range(12)))
registerGame(GameInfo(13014, DoubleDojoujisGame, "Dojouji's Game Doubled",
GI.GT_HANAFUDA, 4, 0,
GI.GT_HANAFUDA, 4, 0, GI.SL_BALANCED,
suits = range(12), ranks = range(4)))

4
pysollib/games/ultra/matrix.py
View file

@ -427,7 +427,7 @@ 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.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})
@ -453,7 +453,7 @@ def r(id, gameclass, short_name):
ncards = 0
for n in gameclass.ROWS:
ncards = ncards + n
gi = GameInfo(id, gameclass, name, GI.GT_MATRIX, 1, 0,
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})

40
pysollib/games/ultra/mughal.py
View file

@ -1145,30 +1145,30 @@ class AshtaDikapala(Game):
# //
# ************************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
suits=range(8), ranks=range(12))
registerGame(gi)
return gi
r(14401, MughalCircles, 'Mughal Circles', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14402, Ghulam, 'Ghulam', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14403, Shamsher, 'Shamsher', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14404, EightLegions, 'Eight Legions', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14405, Ashrafi, 'Ashrafi', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14406, Tipati, 'Tipati', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14407, Ashwapati, 'Ashwapati', GI.GT_MUGHAL_GANJIFA, 1, -1)
r(14408, Gajapati, 'Gajapati', GI.GT_MUGHAL_GANJIFA, 1, -1)
r(14409, Narpati, 'Narpati', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14410, Garhpati, 'Garhpati', GI.GT_MUGHAL_GANJIFA, 1, -1)
r(14411, Dhanpati, 'Dhanpati', GI.GT_MUGHAL_GANJIFA, 1, 1)
r(14412, AkbarsTriumph, 'Akbar\'s Triumph', GI.GT_MUGHAL_GANJIFA, 1, 2)
r(14413, AkbarsConquest, 'Akbar\'s Conquest', GI.GT_MUGHAL_GANJIFA, 2, 2)
r(16000, Vajra, 'Vajra', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(16001, Danda, 'Danda', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(16002, Khadga, 'Khadga', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(16003, Makara, 'Makara', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(16004, AshtaDikapala, 'Ashta Dikapala', GI.GT_MUGHAL_GANJIFA, 1, 0)
r(14401, MughalCircles, 'Mughal Circles', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(14402, Ghulam, 'Ghulam', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(14403, Shamsher, 'Shamsher', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(14404, EightLegions, 'Eight Legions', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(14405, Ashrafi, 'Ashrafi', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(14406, Tipati, 'Tipati', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_BALANCED)
r(14407, Ashwapati, 'Ashwapati', GI.GT_MUGHAL_GANJIFA, 1, -1, GI.SL_BALANCED)
r(14408, Gajapati, 'Gajapati', GI.GT_MUGHAL_GANJIFA, 1, -1, GI.SL_BALANCED)
r(14409, Narpati, 'Narpati', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_BALANCED)
r(14410, Garhpati, 'Garhpati', GI.GT_MUGHAL_GANJIFA, 1, -1, GI.SL_BALANCED)
r(14411, Dhanpati, 'Dhanpati', GI.GT_MUGHAL_GANJIFA, 1, 1, GI.SL_BALANCED)
r(14412, AkbarsTriumph, 'Akbar\'s Triumph', GI.GT_MUGHAL_GANJIFA, 1, 2, GI.SL_BALANCED)
r(14413, AkbarsConquest, 'Akbar\'s Conquest', GI.GT_MUGHAL_GANJIFA, 2, 2, GI.SL_BALANCED)
r(16000, Vajra, 'Vajra', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(16001, Danda, 'Danda', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(16002, Khadga, 'Khadga', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(16003, Makara, 'Makara', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_MOSTLY_SKILL)
r(16004, AshtaDikapala, 'Ashta Dikapala', GI.GT_MUGHAL_GANJIFA, 1, 0, GI.SL_BALANCED)
del r

14
pysollib/games/ultra/tarock.py
View file

@ -258,17 +258,17 @@ class Rambling(Corkscrew):
# // register the games
# ************************************************************************/
def r(id, gameclass, name, game_type, decks, redeals):
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,
gi = GameInfo(id, gameclass, name, game_type, decks, redeals, skill_level,
ranks=range(14), trumps=range(22))
registerGame(gi)
return gi
r(13163, Cockroach, 'Cockroach', GI.GT_TAROCK, 1, 0)
r(13164, DoubleCockroach, 'Double Cockroach', GI.GT_TAROCK, 2, 0)
r(13165, Corkscrew, 'Corkscrew', GI.GT_TAROCK, 2, 0)
r(13166, Serpent, 'Serpent', GI.GT_TAROCK, 2, 0)
r(13167, Rambling, 'Rambling', GI.GT_TAROCK, 2, 0)
r(13163, Cockroach, 'Cockroach', GI.GT_TAROCK, 1, 0, GI.SL_MOSTLY_SKILL)
r(13164, DoubleCockroach, 'Double Cockroach', GI.GT_TAROCK, 2, 0, GI.SL_MOSTLY_SKILL)
r(13165, Corkscrew, 'Corkscrew', GI.GT_TAROCK, 2, 0, GI.SL_MOSTLY_SKILL)
r(13166, Serpent, 'Serpent', GI.GT_TAROCK, 2, 0, GI.SL_MOSTLY_SKILL)
r(13167, Rambling, 'Rambling', GI.GT_TAROCK, 2, 0, GI.SL_MOSTLY_SKILL)
del r

15
pysollib/games/ultra/threepeaks.py
View file

@ -280,21 +280,20 @@ class ThreePeaksNoScore(ThreePeaks):
# /***********************************************************************
# // Three Peaks Game Non-scoring
# // Le Grande Teton
# ************************************************************************/
class LeGrandeTeton(ThreePeaks):
SCORING = 0
class LeGrandeTeton(ThreePeaksNoScore):
pass
def canUndo(self):
return 1
registerGame(GameInfo(22216, ThreePeaks, "Three Peaks",
GI.GT_PAIRING_TYPE, 1, 0))
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(22231, ThreePeaksNoScore, "Three Peaks Non-scoring",
GI.GT_PAIRING_TYPE, 1, 0))
GI.GT_PAIRING_TYPE, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(22232, LeGrandeTeton, "Le Grande Teton",
GI.GT_TAROCK, 1, 0, ranks=range(14), trumps=range(22)))
GI.GT_TAROCK, 1, 0, GI.SL_BALANCED,
ranks=range(14), trumps=range(22)))

4
pysollib/games/unionsquare.py
View file

@ -176,8 +176,8 @@ class SolidSquare(UnionSquare):
# register the game
registerGame(GameInfo(35, UnionSquare, "Union Square",
GI.GT_2DECK_TYPE, 2, 0,
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_SKILL,
altnames=('British Square',),
))
registerGame(GameInfo(439, SolidSquare, "Solid Square",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_BALANCED))

2
pysollib/games/wavemotion.py
View file

@ -97,4 +97,4 @@ class WaveMotion(Game):
# register the game
registerGame(GameInfo(314, WaveMotion, "Wave Motion",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_SKILL))

10
pysollib/games/windmill.py
View file

@ -321,13 +321,13 @@ class FourSeasons(Czarina):
# register the game
registerGame(GameInfo(30, Windmill, "Windmill",
GI.GT_2DECK_TYPE, 2, 0))
GI.GT_2DECK_TYPE, 2, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(277, NapoleonsTomb, "Napoleon's Tomb",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(417, Corners, "Corners",
GI.GT_1DECK_TYPE, 1, 2))
GI.GT_1DECK_TYPE, 1, 2, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(483, Czarina, "Czarina",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(484, FourSeasons, "Four Seasons",
GI.GT_1DECK_TYPE, 1, 0))
GI.GT_1DECK_TYPE, 1, 0, GI.SL_MOSTLY_LUCK))

46
pysollib/games/yukon.py
View file

@ -547,49 +547,49 @@ class Geoffrey(Yukon):
# register the game
registerGame(GameInfo(19, Yukon, "Yukon",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(20, RussianSolitaire, "Russian Solitaire",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(27, Odessa, "Odessa",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(278, Grandfather, "Grandfather",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_MOSTLY_LUCK))
registerGame(GameInfo(186, Alaska, "Alaska",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(187, ChineseDiscipline, "Chinese Discipline",
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0))
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.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(189, Queenie, "Queenie",
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0))
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(190, Rushdike, "Rushdike",
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0))
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(191, RussianPoint, "Russian Point",
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0))
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(192, Abacus, "Abacus",
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0))
GI.GT_YUKON | GI.GT_XORIGINAL, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(271, DoubleYukon, "Double Yukon",
GI.GT_YUKON, 2, 0))
GI.GT_YUKON, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(272, TripleYukon, "Triple Yukon",
GI.GT_YUKON, 3, 0))
GI.GT_YUKON, 3, 0, GI.SL_BALANCED))
registerGame(GameInfo(284, TenAcross, "Ten Across",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(285, Panopticon, "Panopticon",
GI.GT_YUKON | GI.GT_ORIGINAL, 1, 0))
GI.GT_YUKON | GI.GT_ORIGINAL, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(339, Moosehide, "Moosehide",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(387, Roslin, "Roslin",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_MOSTLY_SKILL))
registerGame(GameInfo(447, AustralianPatience, "Australian Patience",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(450, RawPrawn, "Raw Prawn",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_BALANCED))
registerGame(GameInfo(456, BimBom, "Bim Bom",
GI.GT_YUKON | GI.GT_ORIGINAL, 2, 0))
GI.GT_YUKON | GI.GT_ORIGINAL, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(466, DoubleRussianSolitaire, "Double Russian Solitaire",
GI.GT_YUKON, 2, 0))
GI.GT_YUKON, 2, 0, GI.SL_BALANCED))
registerGame(GameInfo(488, TripleRussianSolitaire, "Triple Russian Solitaire",
GI.GT_YUKON, 3, 0))
GI.GT_YUKON, 3, 0, GI.SL_BALANCED))
registerGame(GameInfo(492, Geoffrey, "Geoffrey",
GI.GT_YUKON, 1, 0))
GI.GT_YUKON, 1, 0, GI.SL_MOSTLY_SKILL))

2
pysollib/games/zodiac.py
View file

@ -123,4 +123,4 @@ class Zodiac(Game):
# register the game
registerGame(GameInfo(467, Zodiac, "Zodiac",
GI.GT_2DECK_TYPE, 2, -1))
GI.GT_2DECK_TYPE, 2, -1, GI.SL_BALANCED))

9
pysollib/tk/gameinfodialog.py
View file

@ -71,6 +71,14 @@ class GameInfoDialog(MfxDialog):
if gi.si.game_flags & t:
flags.append(attr)
#
sl = {
1: 'SL_LUCK',
2: 'SL_MOSTLY_LUCK',
3: 'SL_BALANCED',
4: 'SL_MOSTLY_SKILL',
5: 'SL_SKILL',
}
skill_level = sl.get(gi.skill_level)
row = 0
for n, t in (('Name:', gi.name),
('Short name:', gi.short_name),
@ -82,6 +90,7 @@ class GameInfoDialog(MfxDialog):
('Category:', cat),
('Type:', type),
('Flags:', '\n'.join(flags)),
('Skill level:', skill_level),
('Rules filename:', gi.rules_filename),
('Module:', game.__module__),
('Class:', game.__class__.__name__),

16
pysollib/tk/menubar.py
View file

@ -199,7 +199,7 @@ class PysolMenubar(PysolMenubarActions):
def __init__(self, app, top):
PysolMenubarActions.__init__(self, app, top)
# init columnbreak
self.__cb_max = int(self.top.winfo_screenheight()/22)
self.__cb_max = int(self.top.winfo_screenheight()/23)
## sh = self.top.winfo_screenheight()
## self.__cb_max = 22
## if sh >= 600: self.__cb_max = 27
@ -353,7 +353,7 @@ class PysolMenubar(PysolMenubarActions):
submenu = MfxMenu(menu, label=n_("Card &view"))
submenu.add_checkbutton(label=n_("Card shado&w"), variable=self.tkopt.shadow, command=self.mOptShadow)
submenu.add_checkbutton(label=n_("Shade &legal moves"), variable=self.tkopt.shade, command=self.mOptShade)
submenu.add_checkbutton(label=n_("&Negative card bottom"), variable=self.tkopt.negative_bottom, command=self.mOptNegativeBottom)
submenu.add_checkbutton(label=n_("&Negative cards bottom"), variable=self.tkopt.negative_bottom, command=self.mOptNegativeBottom)
submenu = MfxMenu(menu, label=n_("A&nimations"))
submenu.add_radiobutton(label=n_("&None"), variable=self.tkopt.animations, value=0, command=self.mOptAnimations)
submenu.add_radiobutton(label=n_("&Timer based"), variable=self.tkopt.animations, value=2, command=self.mOptAnimations)
@ -693,14 +693,10 @@ class PysolMenubar(PysolMenubarActions):
submenu = self.__menupath[".menubar.file.favoritegames"][2]
submenu.delete(0, "last")
# insert games
for id in gameids:
gi = self.app.getGameInfo(id)
if not gi:
continue
submenu.add_radiobutton(command=self.mSelectGame,
variable=self.tkopt.gameid,
value=gi.id, label=gi.name)
g = [self.app.getGameInfo(id) for id in gameids]
self._addSelectGameSubSubMenu(submenu, g,
command=self.mSelectGame,
variable=self.tkopt.gameid)
state = self._getEnabledState
in_favor = self.app.game.id in gameids
menu, index, submenu = self.__menupath[".menubar.file.addtofavorites"]

7
pysollib/tk/selectgame.py
View file

@ -175,6 +175,13 @@ class SelectGameData(SelectDialogTreeData):
s_oriental,
s_special,
s_by_type,
SelectGameNode(None, _('by Skill Level'), (
SelectGameNode(None, _('Luck only'), lambda gi: gi.skill_level == GI.SL_LUCK),
SelectGameNode(None, _('Mostly luck'), lambda gi: gi.skill_level == GI.SL_MOSTLY_LUCK),
SelectGameNode(None, _('Balanced'), lambda gi: gi.skill_level == GI.SL_BALANCED),
SelectGameNode(None, _('Mostly skill'), lambda gi: gi.skill_level == GI.SL_MOSTLY_SKILL),
SelectGameNode(None, _('Skill only'), lambda gi: gi.skill_level == GI.SL_SKILL),
)),
SelectGameNode(None, _("by Game Feature"), (
SelectGameNode(None, _("by Number of Cards"), (
SelectGameNode(None, _("32 cards"), lambda gi: gi.si.ncards == 32),

4
pysollib/tk/tkstats.py
View file

@ -560,7 +560,9 @@ class AllGames_StatsDialog(MfxDialog):
bbox = self.canvas.bbox("all")
##print bbox
##self.canvas.config(scrollregion=bbox)
self.canvas.config(scrollregion=(0,0,bbox[2],bbox[3]))
dx, dy = 4, 0
self.canvas.config(scrollregion=(-dx,-dy,bbox[2]+dx,bbox[3]+dy))
self.canvas.xview_moveto(-dx)
self.canvas.yview_moveto(self.YVIEW)
#
focus = self.createButtons(bottom_frame, kw)

10
scripts/all_games.py
View file

@ -198,7 +198,7 @@ msgstr ""
for g in games_list:
print 'msgid "%s"\nmsgstr ""\n' % g.encode('utf-8')
def plain_text():
def old_plain_text():
#get_games_func = GAME_DB.getGamesIdSortedById
get_games_func = GAME_DB.getGamesIdSortedByName
games_list = {} # for unique
@ -214,6 +214,14 @@ def plain_text():
for g in games_list:
print g.encode('utf-8')
def plain_text():
get_games_func = GAME_DB.getGamesIdSortedByName
for id in get_games_func():
gi = GAME_DB.get(id)
if gi.category == GI.GC_FRENCH:
name = gi.name.lower()
name = re.sub('\W', '', name)
print id, name #, gi.si.game_type, gi.si.game_type == GI.GC_FRENCH
##