Implemented the reveal/hide solution functionality

[getaclue.git] / crosswordpuzzle.py

diff --git a/crosswordpuzzle.py b/crosswordpuzzle.py
index d02890b..ffdd915 100644 (file)
--- a/crosswordpuzzle.py
+++ b/crosswordpuzzle.py
@@ -109,6 +109,11 @@ class NoWordException (Exception):
        def __init__ (self, row, col):
                self.pos = (row, col)
 
+# exception when a word number is not found in the grid
+class NoNumberException (Exception):
+       def __init__ (self, num):
+               self.num = num
+
 # exception when no words are present in the grid
 class NoWordsException (Exception):
        def __init__ (self):
@@ -299,6 +304,53 @@ class CrosswordPuzzle:
 
                return clues
 
+       # getting an across word at a number (note that the grid should be
+       # frozen for calling this otherwise a FrozenGridException will be raised)
+       def get_word_across_at_num (self, num):
+               # assert that the grid is frozen
+               self.assert_frozen_grid ()
+
+               # traverse the grid
+               for row in range (self.rows):
+                       for col in range (self.cols):
+                               if self.data[row][col].numbered == num:
+                                       word = self.get_word_across (row, col)
+                                       return word
+
+               # if number is not found
+               raise NoNumberException (num)
+
+       # getting a down word at a number (note that the grid should be frozen
+       # for calling this otherwise a FrozenGridException will be raised)
+       def get_word_down_at_num (self, num):
+               # assert that the grid is frozen
+               self.assert_frozen_grid ()
+
+               # traverse the grid
+               for row in range (self.rows):
+                       for col in range (self.cols):
+                               if self.data[row][col].numbered == num:
+                                       word = self.get_word_down (row, col)
+                                       return word
+
+               # if number is not found
+               raise NoNumberException (num)
+
+       # getting the position of a number on the grid (note that the grid should
+       # be frozen for calling this otherwise a FrozenGridException will be raised)
+       def get_position_of_num (self, num):
+               # assert that the grid is frozen
+               self.assert_frozen_grid ()
+
+               # traverse the grid
+               for row in range (self.rows):
+                       for col in range (self.cols):
+                               if self.data[row][col].numbered == num:
+                                       return (row, col)
+
+               # if number is not found
+               raise NoNumberException (num)
+
        # getting a down word at a position
        def get_word_down (self, row, col):
                # if index is out of bounds
@@ -530,13 +582,13 @@ class CrosswordPuzzle:
        # remove an across word at position
        def remove_word_across (self, row, col):
                # if grid is frozen don't allow removal of word
-               assert_unfrozen_grid ()
+               self.assert_unfrozen_grid ()
 
                word, brow, bcol, l = self.get_word_across (row, col)
 
                # traverse from the beginning to end of the word and erase it
                c = bcol
-               while True:
+               while c < self.cols:
                        if self.data[brow][c].occupied_across is True:
                                self.data[brow][c].clear_across_data ()
                        else:
@@ -551,12 +603,44 @@ class CrosswordPuzzle:
                word, brow, bcol, l = self.get_word_down (row, col)
                # traverse from the beginn to end of the word and erase it
                r = brow
-               while True:
+               while r < self.rows:
                        if self.data[r][bcol].occupied_down is True:
                                self.data[r][bcol].clear_down_data ()
                        else:
                                break
                        r += 1
 
+       # reveal/unreveal a word at position
+       def reveal_word_across (self, row, col, revealed=True):
+               # set the revealed flag for the word at the position
+               word= self.get_word_across (row, col)
+
+               c = word[2]
+               while c < self.cols:
+                       if self.data[word[1]][c].occupied_across is True:
+                               self.data[word[1]][c].revealed = revealed
+                       else:
+                               break
+                       c += 1
+
+       # reveal/unreveal a word at position
+       def reveal_word_down (self, row, col, revealed=True):
+               # set the revealed flag for the word at the position
+               word = self.get_word_down (row, col)
+
+               r = word[1]
+               while r < self.rows:
+                       if self.data[r][word[2]].occupied_down is True:
+                               self.data[r][word[2]].revealed = revealed
+                       else:
+                               break
+                       r += 1
+
+       # reveal/hide the entire solution by resetting revealed flag at all cells
+       def reveal_solution (self, revealed=True):
+               # run through the grid and set revealed to False
+               for row in range (self.rows):
+                       for col in range (self.cols):
+                               self.data[row][col].revealed = revealed