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

Added Crossword game.

Browse source
This commit is contained in:
Joe R 2021-02-06 09:42:44 -05:00 • committed by Shlomi Fish
parent 0e7ad946a6
commit 9fab5f8d1f
3 changed files with 240 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
html-src/rules/crossword.html Normal file
View file

@ -0,0 +1,20 @@
<h1>Crossword</h1>
<p>
One-Deck game type. 1 deck. No redeal.
<h3>Object</h3>
<p>
Arrange 49 cards into a seven by seven grid.
<h3>Rules</h3>
<p>A single card is dealt in the center of a seven by seven grid. One by one, deal the remaining
cards into the grid, each next to another card, either horizontally, vertically, or diagonally.
Non-face cards in the grid must be played in sequences that total up to even numbers. Once a card
is played, it cannot be moved.
<p>Face cards played in the grid separate the different sequences, similar to how the black
spaces separate words in an actual crossword puzzle. As such, when a face card is played, it is
flipped face down. Two face cards cannot be played directly adjacent to each other horizontally or
vertically (though them touching diagonally is allowed).
<p>Once there is only one open space in the grid remaining, the last four cards in the deck are dealt
out and you can play any one of them into the last space. The game is won if 49 cards can be
successfully played into the grid.

1
pysollib/games/__init__.py
View file

@ -35,6 +35,7 @@ from . import calculation # noqa: F401
from . import camelot # noqa: F401
from . import canfield # noqa: F401
from . import capricieuse # noqa: F401
from . import crossword # noqa: F401
from . import curdsandwhey # noqa: F401
from . import daddylonglegs # noqa: F401
from . import dieboesesieben # noqa: F401

219
pysollib/games/crossword.py Normal file
View file

@ -0,0 +1,219 @@
#!/usr/bin/env python
# -*- mode: python; coding: utf-8; -*-
# ---------------------------------------------------------------------------
#
# Copyright (C) 1998-2003 Markus Franz Xaver Johannes Oberhumer
# Copyright (C) 2003 Mt. Hood Playing Card Co.
# Copyright (C) 2005-2009 Skomoroh
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
#
# ---------------------------------------------------------------------------
from pysollib.game import Game
from pysollib.gamedb import GI, GameInfo, registerGame
from pysollib.layout import Layout
from pysollib.stack import \
OpenTalonStack, \
ReserveStack, \
Stack, \
StackWrapper
# ************************************************************************
# * Crossword
# ************************************************************************
class Crossword_RowStack(ReserveStack):
def clickHandler(self, event):
if (not self.cards and self.game.s.talon.cards and
self.game.isValidPlay(self.id,
self.game.s.talon.getCard().rank + 1)):
self.game.s.talon.playMoveMove(1, self)
return 1
return ReserveStack.clickHandler(self, event)
rightclickHandler = clickHandler
def acceptsCards(self, from_stack, cards):
return not self.cards and self.game.isValidPlay(self.id,
cards[0].rank + 1)
def canFlipCard(self):
return False
def closeStack(self):
if (self.cards[0].rank >= 10):
self.flipMove()
if len(self.game.s.talon.cards) == 4:
self.game.s.talon.flipMove()
for r in self.game.s.reserves:
self.game.s.talon.moveMove(1, r)
class Crossword_FinalCard(ReserveStack):
def rightclickHandler(self, event):
if (self.cards):
for r in self.game.s.rows:
if (not r.cards and
self.game.isValidPlay(r.id, self.cards[0].rank + 1)):
self.playMoveMove(1, r)
def acceptsCards(self, from_stack, cards):
return (len(self.game.s.talon.cards) <= 4 and
from_stack == self.game.s.talon)
def canMoveCards(self, cards):
return True
getBottomImage = Stack._getNoneBottomImage
class Crossword(Game):
Talon_Class = OpenTalonStack
RowStack_Class = StackWrapper(Crossword_RowStack, max_move=0)
FinalCards_Class = StackWrapper(Crossword_FinalCard, max_move=0)
Hint_Class = None
#
# game layout
#
def createGame(self):
# create layout
l, s = Layout(self), self.s
ta = "ss"
x, y = l.XM, l.YM + 2 * l.YS
# set window
w = max(2 * l.XS, x)
self.setSize(l.XM + w + 7 * l.XS + 50, l.YM + 7 * l.YS + 30)
# create stacks
for i in range(7):
for j in range(7):
x, y = l.XM + w + j * l.XS, l.YM + i * l.YS
s.rows.append(self.RowStack_Class(x, y, self))
x, y = l.XM, l.YM
# set up spots for final cards
for i in range(4):
x, y = l.XM, w + l.YM + i * l.YS
s.reserves.append(self.FinalCards_Class(x, y, self))
x, y = l.XM, l.YM
s.talon = self.Talon_Class(x, y, self)
l.createText(s.talon, anchor=ta)
# define rows to check for sequences
r = s.rows
self.crossword_rows = [
r[0:7], r[7:14], r[14:21], r[21:28],
r[28:35], r[35:42], r[42:49],
(r[0], r[0+7], r[0+14], r[0+21], r[0+28], r[0+35], r[0+42]),
(r[1], r[1+7], r[1+14], r[1+21], r[1+28], r[1+35], r[1+42]),
(r[2], r[2+7], r[2+14], r[2+21], r[2+28], r[2+35], r[2+42]),
(r[3], r[3+7], r[3+14], r[3+21], r[3+28], r[3+35], r[3+42]),
(r[4], r[4+7], r[4+14], r[4+21], r[4+28], r[4+35], r[4+42]),
(r[5], r[5+7], r[5+14], r[5+21], r[5+28], r[5+35], r[5+42]),
(r[6], r[6+7], r[6+14], r[6+21], r[6+28], r[6+35], r[6+42])
]
self.crossword_rows = list(map(tuple, self.crossword_rows))
# define stack-groups
l.defaultStackGroups()
return l
def startGame(self):
self.moveMove(1, self.s.talon, self.s.rows[24], frames=0)
self.s.rows[24].flipMove()
self.s.talon.fillStack()
def isGameWon(self):
if len(self.s.talon.cards) == 0:
for r in self.s.reserves:
if (not r.cards):
return True
return False
def isValidPlay(self, playSpace, playRank):
# check that there's an adjacent card
if (not self.adjacentCard(playSpace)):
return False
# check the totals
for hand in self.crossword_rows:
count = 0 # count of the sequence
hasEmpties = False # Whether the sequence still has empty spaces
lastFace = False # Was the last card a face card?
for s in hand:
if s.id == playSpace:
rank = playRank
elif s.cards:
rank = s.cards[0].rank + 1
else:
rank = -1
hasEmpties = True
lastFace = False
if (rank > -1):
if (rank < 11):
count += rank
lastFace = False
else:
if ((count % 2) != 0 and not hasEmpties) or lastFace:
return False
else:
count = 0
hasEmpties = False
lastFace = True
if (count % 2) != 0 and not hasEmpties:
return False
return True
def adjacentCard(self, playSpace):
if (playSpace % 7 != 6 and self.s.rows[playSpace + 1].cards):
return True
if (playSpace % 7 != 0 and self.s.rows[playSpace - 1].cards):
return True
if (playSpace + 7 < 49 and self.s.rows[playSpace + 7].cards):
return True
if (playSpace - 7 > 0 and self.s.rows[playSpace - 7].cards):
return True
if (playSpace % 7 != 6 and playSpace - 6 > 0
and self.s.rows[playSpace - 6].cards):
return True
if (playSpace % 7 != 0 and playSpace - 8 > 0
and self.s.rows[playSpace - 8].cards):
return True
if (playSpace % 7 != 0 and playSpace + 6 < 49
and self.s.rows[playSpace + 6].cards):
return True
if (playSpace % 7 != 6 and playSpace + 8 < 49
and self.s.rows[playSpace + 8].cards):
return True
return False
# register the game
registerGame(GameInfo(778, Crossword, "Crossword",
GI.GT_1DECK_TYPE, 1, 0, GI.SL_BALANCED))