From 49adfd35135bdbc3d4aae7f031dc209ad27d9642 Mon Sep 17 00:00:00 2001 From: skomoroh Date: Wed, 21 Jun 2006 21:27:05 +0000 Subject: [PATCH] + new selection type: `by skill level' + 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 --- po/ru_pysol.po | 4 +- pysollib/acard.py | 9 ++- pysollib/app.py | 2 + pysollib/gamedb.py | 34 ++++----- pysollib/games/acesup.py | 10 +-- pysollib/games/algerian.py | 6 +- pysollib/games/auldlangsyne.py | 14 ++-- pysollib/games/bakersdozen.py | 20 +++--- pysollib/games/bakersgame.py | 14 ++-- pysollib/games/beleagueredcastle.py | 32 ++++----- pysollib/games/bisley.py | 10 +-- pysollib/games/braid.py | 12 ++-- pysollib/games/bristol.py | 10 +-- pysollib/games/buffalobill.py | 4 +- pysollib/games/calculation.py | 6 +- pysollib/games/camelot.py | 2 +- pysollib/games/canfield.py | 38 +++++----- pysollib/games/capricieuse.py | 4 +- pysollib/games/contrib/sanibel.py | 2 +- pysollib/games/curdsandwhey.py | 24 +++---- pysollib/games/dieboesesieben.py | 2 +- pysollib/games/diplomat.py | 12 ++-- pysollib/games/doublets.py | 2 +- pysollib/games/eiffeltower.py | 2 +- pysollib/games/fan.py | 28 ++++---- pysollib/games/fortythieves.py | 74 +++++++++---------- pysollib/games/freecell.py | 34 ++++----- pysollib/games/glenwood.py | 2 +- pysollib/games/golf.py | 20 +++--- pysollib/games/grandfathersclock.py | 2 +- pysollib/games/gypsy.py | 44 ++++++------ pysollib/games/harp.py | 20 +++--- pysollib/games/headsandtails.py | 2 +- pysollib/games/katzenschwanz.py | 12 ++-- pysollib/games/klondike.py | 102 +++++++++++++-------------- pysollib/games/mahjongg/mahjongg.py | 2 +- pysollib/games/mahjongg/shisensho.py | 2 +- pysollib/games/matriarchy.py | 2 +- pysollib/games/montana.py | 16 ++--- pysollib/games/montecarlo.py | 24 +++---- pysollib/games/napoleon.py | 8 +-- pysollib/games/needle.py | 6 +- pysollib/games/numerica.py | 22 +++--- pysollib/games/osmosis.py | 12 ++-- pysollib/games/parallels.py | 2 +- pysollib/games/pasdedeux.py | 2 +- pysollib/games/picturegallery.py | 8 +-- pysollib/games/pileon.py | 4 +- pysollib/games/poker.py | 4 +- pysollib/games/pushpin.py | 4 +- pysollib/games/pyramid.py | 4 +- pysollib/games/royalcotillion.py | 18 ++--- pysollib/games/royaleast.py | 2 +- pysollib/games/siebenbisas.py | 4 +- pysollib/games/simplex.py | 2 +- pysollib/games/special/hanoi.py | 8 +-- pysollib/games/special/memory.py | 8 +-- pysollib/games/special/pegged.py | 2 +- pysollib/games/special/tarock.py | 31 ++++---- pysollib/games/spider.py | 82 ++++++++++----------- pysollib/games/sthelena.py | 4 +- pysollib/games/sultan.py | 24 +++---- pysollib/games/takeaway.py | 4 +- pysollib/games/terrace.py | 14 ++-- pysollib/games/tournament.py | 6 +- pysollib/games/ultra/dashavatara.py | 40 +++++------ pysollib/games/ultra/hanafuda.py | 56 +++++++-------- pysollib/games/ultra/hanafuda1.py | 34 ++++----- pysollib/games/ultra/hexadeck.py | 40 +++++------ pysollib/games/ultra/larasgame.py | 31 ++++---- pysollib/games/ultra/matrix.py | 4 +- pysollib/games/ultra/mughal.py | 40 +++++------ pysollib/games/ultra/tarock.py | 14 ++-- pysollib/games/ultra/threepeaks.py | 15 ++-- pysollib/games/unionsquare.py | 4 +- pysollib/games/wavemotion.py | 2 +- pysollib/games/windmill.py | 10 +-- pysollib/games/yukon.py | 46 ++++++------ pysollib/games/zodiac.py | 2 +- pysollib/tk/gameinfodialog.py | 9 +++ pysollib/tk/menubar.py | 16 ++--- pysollib/tk/selectgame.py | 7 ++ pysollib/tk/tkstats.py | 4 +- scripts/all_games.py | 10 ++- 84 files changed, 676 insertions(+), 654 deletions(-) diff --git a/po/ru_pysol.po b/po/ru_pysol.po index cb0eef34..85412367 100644 --- a/po/ru_pysol.po +++ b/po/ru_pysol.po @@ -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: Скоморох \n" "Language-Team: Russian \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" diff --git a/pysollib/acard.py b/pysollib/acard.py index 81ac4b4a..e23f09c7 100644 --- a/pysollib/acard.py +++ b/pysollib/acard.py @@ -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). diff --git a/pysollib/app.py b/pysollib/app.py index bbdbcde3..50222aa6 100644 --- a/pysollib/app.py +++ b/pysollib/app.py @@ -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): diff --git a/pysollib/gamedb.py b/pysollib/gamedb.py index cc566b9c..c7ab0167 100644 --- a/pysollib/gamedb.py +++ b/pysollib/gamedb.py @@ -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) diff --git a/pysollib/games/acesup.py b/pysollib/games/acesup.py index 5df310cf..5c64663a 100644 --- a/pysollib/games/acesup.py +++ b/pysollib/games/acesup.py @@ -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)) diff --git a/pysollib/games/algerian.py b/pysollib/games/algerian.py index ce375ceb..ffab0455 100644 --- a/pysollib/games/algerian.py +++ b/pysollib/games/algerian.py @@ -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)) diff --git a/pysollib/games/auldlangsyne.py b/pysollib/games/auldlangsyne.py index f654e657..0bb1a914 100644 --- a/pysollib/games/auldlangsyne.py +++ b/pysollib/games/auldlangsyne.py @@ -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)) diff --git a/pysollib/games/bakersdozen.py b/pysollib/games/bakersdozen.py index f3cbf8d7..1ceb4e8d 100644 --- a/pysollib/games/bakersdozen.py +++ b/pysollib/games/bakersdozen.py @@ -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)) diff --git a/pysollib/games/bakersgame.py b/pysollib/games/bakersgame.py index 6ea1147d..a43789a5 100644 --- a/pysollib/games/bakersgame.py +++ b/pysollib/games/bakersgame.py @@ -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)) diff --git a/pysollib/games/beleagueredcastle.py b/pysollib/games/beleagueredcastle.py index 0617beda..e33c773d 100644 --- a/pysollib/games/beleagueredcastle.py +++ b/pysollib/games/beleagueredcastle.py @@ -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)) diff --git a/pysollib/games/bisley.py b/pysollib/games/bisley.py index 279de5a7..ebb22cca 100644 --- a/pysollib/games/bisley.py +++ b/pysollib/games/bisley.py @@ -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)) diff --git a/pysollib/games/braid.py b/pysollib/games/braid.py index 85e555e7..b00a6200 100644 --- a/pysollib/games/braid.py +++ b/pysollib/games/braid.py @@ -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)) diff --git a/pysollib/games/bristol.py b/pysollib/games/bristol.py index 528c4bdf..82d17b87 100644 --- a/pysollib/games/bristol.py +++ b/pysollib/games/bristol.py @@ -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)) diff --git a/pysollib/games/buffalobill.py b/pysollib/games/buffalobill.py index aad131ee..24c0ebd4 100644 --- a/pysollib/games/buffalobill.py +++ b/pysollib/games/buffalobill.py @@ -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)) diff --git a/pysollib/games/calculation.py b/pysollib/games/calculation.py index 35de5cb4..80a5bcfa 100644 --- a/pysollib/games/calculation.py +++ b/pysollib/games/calculation.py @@ -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") )) diff --git a/pysollib/games/camelot.py b/pysollib/games/camelot.py index 16ed9edb..8ddb419e 100644 --- a/pysollib/games/camelot.py +++ b/pysollib/games/camelot.py @@ -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)) diff --git a/pysollib/games/canfield.py b/pysollib/games/canfield.py index c1a58d21..254b160e 100644 --- a/pysollib/games/canfield.py +++ b/pysollib/games/canfield.py @@ -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)) diff --git a/pysollib/games/capricieuse.py b/pysollib/games/capricieuse.py index dac3860d..e7beec99 100644 --- a/pysollib/games/capricieuse.py +++ b/pysollib/games/capricieuse.py @@ -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)) diff --git a/pysollib/games/contrib/sanibel.py b/pysollib/games/contrib/sanibel.py index 6760987f..7d6f9d00 100644 --- a/pysollib/games/contrib/sanibel.py +++ b/pysollib/games/contrib/sanibel.py @@ -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)) diff --git a/pysollib/games/curdsandwhey.py b/pysollib/games/curdsandwhey.py index 07bdb472..4f9fa7c2 100644 --- a/pysollib/games/curdsandwhey.py +++ b/pysollib/games/curdsandwhey.py @@ -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)) diff --git a/pysollib/games/dieboesesieben.py b/pysollib/games/dieboesesieben.py index 2fb6f884..e3c7d8e4 100644 --- a/pysollib/games/dieboesesieben.py +++ b/pysollib/games/dieboesesieben.py @@ -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",) )) diff --git a/pysollib/games/diplomat.py b/pysollib/games/diplomat.py index 1f87a62f..312d0877 100644 --- a/pysollib/games/diplomat.py +++ b/pysollib/games/diplomat.py @@ -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)) diff --git a/pysollib/games/doublets.py b/pysollib/games/doublets.py index 6b1f1ed3..e6751384 100644 --- a/pysollib/games/doublets.py +++ b/pysollib/games/doublets.py @@ -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)) diff --git a/pysollib/games/eiffeltower.py b/pysollib/games/eiffeltower.py index 9e53595a..b55f855b 100644 --- a/pysollib/games/eiffeltower.py +++ b/pysollib/games/eiffeltower.py @@ -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)) diff --git a/pysollib/games/fan.py b/pysollib/games/fan.py index cc02c783..cf83fb5a 100644 --- a/pysollib/games/fan.py +++ b/pysollib/games/fan.py @@ -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)) diff --git a/pysollib/games/fortythieves.py b/pysollib/games/fortythieves.py index e9e9a530..7f62bf2f 100644 --- a/pysollib/games/fortythieves.py +++ b/pysollib/games/fortythieves.py @@ -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)) diff --git a/pysollib/games/freecell.py b/pysollib/games/freecell.py index 0a71684c..3aafff6c 100644 --- a/pysollib/games/freecell.py +++ b/pysollib/games/freecell.py @@ -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)) diff --git a/pysollib/games/glenwood.py b/pysollib/games/glenwood.py index fd54bf72..774fd83e 100644 --- a/pysollib/games/glenwood.py +++ b/pysollib/games/glenwood.py @@ -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)) diff --git a/pysollib/games/golf.py b/pysollib/games/golf.py index 648dd1c7..0da34ffc 100644 --- a/pysollib/games/golf.py +++ b/pysollib/games/golf.py @@ -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)) diff --git a/pysollib/games/grandfathersclock.py b/pysollib/games/grandfathersclock.py index d2993ada..db9be246 100644 --- a/pysollib/games/grandfathersclock.py +++ b/pysollib/games/grandfathersclock.py @@ -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)) diff --git a/pysollib/games/gypsy.py b/pysollib/games/gypsy.py index af286125..40fed9c1 100644 --- a/pysollib/games/gypsy.py +++ b/pysollib/games/gypsy.py @@ -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)) diff --git a/pysollib/games/harp.py b/pysollib/games/harp.py index e7566be0..c86100e8 100644 --- a/pysollib/games/harp.py +++ b/pysollib/games/harp.py @@ -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)) diff --git a/pysollib/games/headsandtails.py b/pysollib/games/headsandtails.py index 77d8c703..cae00cde 100644 --- a/pysollib/games/headsandtails.py +++ b/pysollib/games/headsandtails.py @@ -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)) diff --git a/pysollib/games/katzenschwanz.py b/pysollib/games/katzenschwanz.py index 51a215f3..7da00236 100644 --- a/pysollib/games/katzenschwanz.py +++ b/pysollib/games/katzenschwanz.py @@ -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)) diff --git a/pysollib/games/klondike.py b/pysollib/games/klondike.py index 82de9dca..06a81494 100644 --- a/pysollib/games/klondike.py +++ b/pysollib/games/klondike.py @@ -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)) diff --git a/pysollib/games/mahjongg/mahjongg.py b/pysollib/games/mahjongg/mahjongg.py index 6f26e6f0..3f542d74 100644 --- a/pysollib/games/mahjongg/mahjongg.py +++ b/pysollib/games/mahjongg/mahjongg.py @@ -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}) diff --git a/pysollib/games/mahjongg/shisensho.py b/pysollib/games/mahjongg/shisensho.py index 5a231de3..58c05b69 100644 --- a/pysollib/games/mahjongg/shisensho.py +++ b/pysollib/games/mahjongg/shisensho.py @@ -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}) diff --git a/pysollib/games/matriarchy.py b/pysollib/games/matriarchy.py index ee704826..84f8d4e4 100644 --- a/pysollib/games/matriarchy.py +++ b/pysollib/games/matriarchy.py @@ -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)) diff --git a/pysollib/games/montana.py b/pysollib/games/montana.py index 8fc3f2c4..a3ca410b 100644 --- a/pysollib/games/montana.py +++ b/pysollib/games/montana.py @@ -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)) diff --git a/pysollib/games/montecarlo.py b/pysollib/games/montecarlo.py index 2cb3c029..f296c137 100644 --- a/pysollib/games/montecarlo.py +++ b/pysollib/games/montecarlo.py @@ -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)) diff --git a/pysollib/games/napoleon.py b/pysollib/games/napoleon.py index 69ee4696..9b21e254 100644 --- a/pysollib/games/napoleon.py +++ b/pysollib/games/napoleon.py @@ -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)) diff --git a/pysollib/games/needle.py b/pysollib/games/needle.py index f95eb6f0..be541857 100644 --- a/pysollib/games/needle.py +++ b/pysollib/games/needle.py @@ -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)) diff --git a/pysollib/games/numerica.py b/pysollib/games/numerica.py index ca24b5cf..d8dd320c 100644 --- a/pysollib/games/numerica.py +++ b/pysollib/games/numerica.py @@ -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)) diff --git a/pysollib/games/osmosis.py b/pysollib/games/osmosis.py index 7c1f907a..f30b928b 100644 --- a/pysollib/games/osmosis.py +++ b/pysollib/games/osmosis.py @@ -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)) diff --git a/pysollib/games/parallels.py b/pysollib/games/parallels.py index 1c196788..4eb5da93 100644 --- a/pysollib/games/parallels.py +++ b/pysollib/games/parallels.py @@ -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)) diff --git a/pysollib/games/pasdedeux.py b/pysollib/games/pasdedeux.py index 38bab75c..3fc5d242 100644 --- a/pysollib/games/pasdedeux.py +++ b/pysollib/games/pasdedeux.py @@ -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)) diff --git a/pysollib/games/picturegallery.py b/pysollib/games/picturegallery.py index f120b5eb..d329ee9f 100644 --- a/pysollib/games/picturegallery.py +++ b/pysollib/games/picturegallery.py @@ -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)) diff --git a/pysollib/games/pileon.py b/pysollib/games/pileon.py index e1203bc2..f78187d0 100644 --- a/pysollib/games/pileon.py +++ b/pysollib/games/pileon.py @@ -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)", diff --git a/pysollib/games/poker.py b/pysollib/games/poker.py index daea0437..4257b8e7 100644 --- a/pysollib/games/poker.py +++ b/pysollib/games/poker.py @@ -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})) diff --git a/pysollib/games/pushpin.py b/pysollib/games/pushpin.py index 4ce6f23a..4f491ff5 100644 --- a/pysollib/games/pushpin.py +++ b/pysollib/games/pushpin.py @@ -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)) diff --git a/pysollib/games/pyramid.py b/pysollib/games/pyramid.py index 22972373..ee0c4a39 100644 --- a/pysollib/games/pyramid.py +++ b/pysollib/games/pyramid.py @@ -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)) diff --git a/pysollib/games/royalcotillion.py b/pysollib/games/royalcotillion.py index c10beae1..5224ad76 100644 --- a/pysollib/games/royalcotillion.py +++ b/pysollib/games/royalcotillion.py @@ -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)) diff --git a/pysollib/games/royaleast.py b/pysollib/games/royaleast.py index 076350b9..64f680af 100644 --- a/pysollib/games/royaleast.py +++ b/pysollib/games/royaleast.py @@ -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)) diff --git a/pysollib/games/siebenbisas.py b/pysollib/games/siebenbisas.py index a722b9cd..e1419612 100644 --- a/pysollib/games/siebenbisas.py +++ b/pysollib/games/siebenbisas.py @@ -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})) diff --git a/pysollib/games/simplex.py b/pysollib/games/simplex.py index 7a3cc4fc..03cd8aec 100644 --- a/pysollib/games/simplex.py +++ b/pysollib/games/simplex.py @@ -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)) diff --git a/pysollib/games/special/hanoi.py b/pysollib/games/special/hanoi.py index 8b39c70f..d790c60d 100644 --- a/pysollib/games/special/hanoi.py +++ b/pysollib/games/special/hanoi.py @@ -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")) diff --git a/pysollib/games/special/memory.py b/pysollib/games/special/memory.py index 2d1e18f1..4bebc4ab 100644 --- a/pysollib/games/special/memory.py +++ b/pysollib/games/special/memory.py @@ -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)) diff --git a/pysollib/games/special/pegged.py b/pysollib/games/special/pegged.py index 08d304b4..376818e4 100644 --- a/pysollib/games/special/pegged.py +++ b/pysollib/games/special/pegged.py @@ -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) diff --git a/pysollib/games/special/tarock.py b/pysollib/games/special/tarock.py index f3bd38fc..aed5f516 100644 --- a/pysollib/games/special/tarock.py +++ b/pysollib/games/special/tarock.py @@ -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 diff --git a/pysollib/games/spider.py b/pysollib/games/spider.py index 02f51d7d..928ee791 100644 --- a/pysollib/games/spider.py +++ b/pysollib/games/spider.py @@ -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)) diff --git a/pysollib/games/sthelena.py b/pysollib/games/sthelena.py index a1030513..1a28b85a 100644 --- a/pysollib/games/sthelena.py +++ b/pysollib/games/sthelena.py @@ -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)) diff --git a/pysollib/games/sultan.py b/pysollib/games/sultan.py index 9967e83c..a2d3d4af 100644 --- a/pysollib/games/sultan.py +++ b/pysollib/games/sultan.py @@ -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)) diff --git a/pysollib/games/takeaway.py b/pysollib/games/takeaway.py index e425c406..4e65dd14 100644 --- a/pysollib/games/takeaway.py +++ b/pysollib/games/takeaway.py @@ -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)) diff --git a/pysollib/games/terrace.py b/pysollib/games/terrace.py index fc1f0da1..802882a9 100644 --- a/pysollib/games/terrace.py +++ b/pysollib/games/terrace.py @@ -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)) diff --git a/pysollib/games/tournament.py b/pysollib/games/tournament.py index fd6ee107..5838320e 100644 --- a/pysollib/games/tournament.py +++ b/pysollib/games/tournament.py @@ -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)) diff --git a/pysollib/games/ultra/dashavatara.py b/pysollib/games/ultra/dashavatara.py index 98a7eeec..8e5ec00f 100644 --- a/pysollib/games/ultra/dashavatara.py +++ b/pysollib/games/ultra/dashavatara.py @@ -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 diff --git a/pysollib/games/ultra/hanafuda.py b/pysollib/games/ultra/hanafuda.py index 658f35f2..21eff49d 100644 --- a/pysollib/games/ultra/hanafuda.py +++ b/pysollib/games/ultra/hanafuda.py @@ -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 diff --git a/pysollib/games/ultra/hanafuda1.py b/pysollib/games/ultra/hanafuda1.py index f6288d80..4ddd5ab3 100644 --- a/pysollib/games/ultra/hanafuda1.py +++ b/pysollib/games/ultra/hanafuda1.py @@ -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 diff --git a/pysollib/games/ultra/hexadeck.py b/pysollib/games/ultra/hexadeck.py index ae236aff..3fcf19cd 100644 --- a/pysollib/games/ultra/hexadeck.py +++ b/pysollib/games/ultra/hexadeck.py @@ -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 diff --git a/pysollib/games/ultra/larasgame.py b/pysollib/games/ultra/larasgame.py index d7124feb..f61180ba 100644 --- a/pysollib/games/ultra/larasgame.py +++ b/pysollib/games/ultra/larasgame.py @@ -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))) diff --git a/pysollib/games/ultra/matrix.py b/pysollib/games/ultra/matrix.py index 6fdaa243..b20304aa 100644 --- a/pysollib/games/ultra/matrix.py +++ b/pysollib/games/ultra/matrix.py @@ -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}) diff --git a/pysollib/games/ultra/mughal.py b/pysollib/games/ultra/mughal.py index b4b85a8a..48c25201 100644 --- a/pysollib/games/ultra/mughal.py +++ b/pysollib/games/ultra/mughal.py @@ -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 diff --git a/pysollib/games/ultra/tarock.py b/pysollib/games/ultra/tarock.py index 331fbdd8..9e49ce1a 100644 --- a/pysollib/games/ultra/tarock.py +++ b/pysollib/games/ultra/tarock.py @@ -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 diff --git a/pysollib/games/ultra/threepeaks.py b/pysollib/games/ultra/threepeaks.py index 0600a54e..1de25809 100644 --- a/pysollib/games/ultra/threepeaks.py +++ b/pysollib/games/ultra/threepeaks.py @@ -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))) diff --git a/pysollib/games/unionsquare.py b/pysollib/games/unionsquare.py index 3fed5d1e..f9870b89 100644 --- a/pysollib/games/unionsquare.py +++ b/pysollib/games/unionsquare.py @@ -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)) diff --git a/pysollib/games/wavemotion.py b/pysollib/games/wavemotion.py index 74b1b5ef..72ba5442 100644 --- a/pysollib/games/wavemotion.py +++ b/pysollib/games/wavemotion.py @@ -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)) diff --git a/pysollib/games/windmill.py b/pysollib/games/windmill.py index 4d1d7389..b52e9567 100644 --- a/pysollib/games/windmill.py +++ b/pysollib/games/windmill.py @@ -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)) diff --git a/pysollib/games/yukon.py b/pysollib/games/yukon.py index c9442e17..d099bb81 100644 --- a/pysollib/games/yukon.py +++ b/pysollib/games/yukon.py @@ -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)) diff --git a/pysollib/games/zodiac.py b/pysollib/games/zodiac.py index aed43fbb..b6cea283 100644 --- a/pysollib/games/zodiac.py +++ b/pysollib/games/zodiac.py @@ -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)) diff --git a/pysollib/tk/gameinfodialog.py b/pysollib/tk/gameinfodialog.py index cb6ee333..27730254 100644 --- a/pysollib/tk/gameinfodialog.py +++ b/pysollib/tk/gameinfodialog.py @@ -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__), diff --git a/pysollib/tk/menubar.py b/pysollib/tk/menubar.py index cd7b277a..9f90173b 100644 --- a/pysollib/tk/menubar.py +++ b/pysollib/tk/menubar.py @@ -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"] diff --git a/pysollib/tk/selectgame.py b/pysollib/tk/selectgame.py index d5575260..056d9733 100644 --- a/pysollib/tk/selectgame.py +++ b/pysollib/tk/selectgame.py @@ -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), diff --git a/pysollib/tk/tkstats.py b/pysollib/tk/tkstats.py index 33723a3e..6bb4f433 100644 --- a/pysollib/tk/tkstats.py +++ b/pysollib/tk/tkstats.py @@ -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) diff --git a/scripts/all_games.py b/scripts/all_games.py index 60686ea0..59f7e447 100755 --- a/scripts/all_games.py +++ b/scripts/all_games.py @@ -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 ##