From 780c399e6f68a95916d84e7e88a067e8fcbec1cc Mon Sep 17 00:00:00 2001
From: Joe R <joeraz5@verizon.net>
Date: Tue, 11 Jan 2022 19:02:32 -0500
Subject: [PATCH] Added Guardian game.

---
 html-src/rules/guardian.html | 30 +++++++++++++++++
 pysollib/gamedb.py           |  4 +--
 pysollib/games/klondike.py   | 62 ++++++++++++++++++++++++++++++++++++
 3 files changed, 94 insertions(+), 2 deletions(-)
 create mode 100644 html-src/rules/guardian.html

diff --git a/html-src/rules/guardian.html b/html-src/rules/guardian.html
new file mode 100644
index 00000000..a5c2d5d9
--- /dev/null
+++ b/html-src/rules/guardian.html
@@ -0,0 +1,30 @@
+<h1>Guardian</h1>
+<p>
+Klondike type. 1 deck. Unlimited redeals.
+
+<h3>Object</h3>
+<p>
+Move all cards to the foundations.
+
+<h3>Rules</h3>
+<p>
+The tableau piles are built in a pyramid-esque layout, with five cards
+in the top layer, four cards in the middle, and three in the bottom.
+Each card forms a tableau pile which can be built down by alternate
+color.  The three bottom layer cards can be filled with any card when
+empty, but the remaining layers cannot be filled.  Cards in the lower
+layers can only be flipped if the two cards overlapping them are
+removed.
+<p>
+Foundations are built up in suit from Ace to King.
+<p>
+Cards are dealt from the stock three at a time, and can be moved to
+foundations or exposed tableau piles.  You can go through the deck
+as many times as needed.
+<p>
+The game is won when all cards are moved to the foundations.
+
+<h3>Notes</h3>
+<p>
+The name of the game comes from the way a single card (especially an
+immovable king) can "guard" multiple cards beneath them.
diff --git a/pysollib/gamedb.py b/pysollib/gamedb.py
index 01e0646e..475b2df3 100644
--- a/pysollib/gamedb.py
+++ b/pysollib/gamedb.py
@@ -425,7 +425,7 @@ class GI:
         ("Paul Alfille", (8,)),
         ("C.L. Baker", (45,)),
         ("David Bernazzani", (314, 830,)),
-        ("Gordon Bower", (763, 783,)),
+        ("Gordon Bower", (763, 783, 852,)),
         ("Art Cabral", (9,)),
         ("Richard A. Canfield", (105, 835,)),
         ("Lillian Davies and Christa Baran", (605,)),
@@ -528,7 +528,7 @@ class GI:
         ('fc-2.12',   tuple(range(774, 811)) + (16681,) +
          tuple(range(22217, 22219))),
         ('fc-2.14', tuple(range(811, 827))),
-        ('fc-2.16', tuple(range(827, 852)) + tuple(range(22400, 22407)))
+        ('fc-2.16', tuple(range(827, 853)) + tuple(range(22400, 22407)))
     )
 
     # deprecated - the correct way is to or a GI.GT_XXX flag
diff --git a/pysollib/games/klondike.py b/pysollib/games/klondike.py
index 0da0f30f..a35db276 100644
--- a/pysollib/games/klondike.py
+++ b/pysollib/games/klondike.py
@@ -1395,6 +1395,66 @@ class EightSages(Klondike):
         self.s.talon.dealCards()
 
 
+# ************************************************************************
+# * Guardian
+# ************************************************************************
+
+class Guardian_RowStack(AC_RowStack):
+    STEP = (3, 3, 3, 4, 4, 4, 4)
+
+    def basicIsBlocked(self):
+        r, step = self.game.s.rows, self.STEP
+        i, n, mylen = self.id, 1, len(step)
+        while i < mylen:
+            i = i + step[i]
+            n = n + 1
+            for j in range(i, i + n):
+                if r[j].cards:
+                    return True
+        return False
+
+    def acceptsCards(self, from_stack, cards):
+        if len(self.cards) == 0 and self.id > 2:
+            return False
+        return AC_RowStack.acceptsCards(self, from_stack, cards)
+
+
+class Guardian(Game):
+
+    def createGame(self):
+        lay, s = Layout(self), self.s
+        self.setSize((7 * lay.XS) + lay.XM,
+                     (2.5 * lay.YS) + (13 * lay.YOFFSET) + lay.YM)
+
+        # create stacks
+        for i in range(3):
+            x = lay.XM + (4 - i) * lay.XS // 2
+            y = lay.YM + lay.TEXT_HEIGHT + lay.YS + i * lay.YS // 4
+            for j in range(i + 3):
+                s.rows.append(Guardian_RowStack(x, y, self))
+                x = x + lay.XS
+
+        x, y = lay.XM, lay.YM
+        s.talon = WasteTalonStack(x, y, self,
+                                  max_rounds=-1, num_deal=3)
+        lay.createText(s.talon, "s")
+        x += lay.XS
+        s.waste = WasteStack(x, y, self)
+        lay.createText(s.waste, "s")
+        x += lay.XS
+        for i in range(4):
+            x += lay.XS
+            s.foundations.append(SS_FoundationStack(x, y, self, i,
+                                                    mod=13, max_move=0))
+        lay.defaultStackGroups()
+
+    def startGame(self):
+        self.startDealSample()
+        self.s.talon.dealRow(rows=self.s.rows[:7], flip=0)
+        self.s.talon.dealRow(rows=self.s.rows[7:])
+        self.s.talon.dealCards()  # deal first card to WasteStack
+
+
 # register the game
 registerGame(GameInfo(2, Klondike, "Klondike",
                       GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED,
@@ -1547,3 +1607,5 @@ registerGame(GameInfo(821, Trigon, "Trigon",
 registerGame(GameInfo(849, RelaxedRaglan, "Relaxed Raglan",
                       GI.GT_RAGLAN | GI.GT_RELAXED | GI.GT_OPEN, 1, 0,
                       GI.SL_MOSTLY_SKILL))
+registerGame(GameInfo(852, Guardian, "Guardian",
+                      GI.GT_KLONDIKE, 1, -1, GI.SL_BALANCED))