Added preliminary unsugarized version

1 files changed, 244 insertions, 0 deletions

diff --git a/wordhunt.py b/wordhunt.py
new file mode 100644
index 0000000..bb0ce3c
--- /dev/null
+++ b/wordhunt.py
@@ -0,0 +1,244 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import gtk
+import gobject
+import pango
+
+import random
+
+class wordhuntgrid(gtk.Table):
+    def __init__(self, size):
+        self.size = size
+        gtk.Table.__init__(self, self.size, self.size)
+        self.dice_labels = []
+        for row in range(self.size):
+            dice_row = []
+            for column in range(self.size):
+                new_label = gtk.Label("A")
+                new_label.modify_font(pango.FontDescription("sans 32"))
+                new_label.show()
+                self.attach(new_label, \
+                            row, row + 1, column, column + 1,
+                            gtk.EXPAND, gtk.EXPAND)
+                dice_row += [new_label]
+            self.dice_labels += [dice_row]
+    def set_dice(self, text, row, column):
+        self.dice_labels[row][column].set_text(text)
+
+    def set_color(self, color, row, column):
+        self.dice_labels[row][column].modify_fg(gtk.STATE_NORMAL, color)
+
+class wordhunt():
+    def __init__(self): 
+        self.dice = [ ["T", "O", "E", "S", "S", "I"],
+                 ["A", "S", "P", "F", "F", "K"],
+                 ["N", "U", "I", "H", "M", "Qu"],
+                 ["O", "B", "J", "O", "A", "B"],
+                 ["L", "N", "H", "N", "R", "Z"],
+                 ["A", "H", "S", "P", "C", "O"],
+                 ["R", "Y", "V", "D", "E", "L"],
+                 ["I", "O", "T", "M", "U", "C"],
+                 ["L", "R", "E", "I", "X", "D"],
+                 ["T", "E", "R", "W", "H", "V"],
+                 ["T", "S", "T", "I", "Y", "D"],
+                 ["W", "N", "G", "E", "E", "H"],
+                 ["E", "R", "T", "T", "Y", "L"],
+                 ["O", "W", "T", "O", "A", "T"],
+                 ["A", "E", "A", "N", "E", "G"],
+                 ["E", "I", "U", "N", "E", "S"] ]
+
+        self.size = 4
+        self.face = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]
+        self.facedie = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]
+        self.new_shuffled_group()
+        self.new_dice_set()
+        self.valid_words = []
+        self.highlight_timer = 0
+        self.remaining_time = 91  #always one second more than needed
+        mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
+        mainwindow.set_size_request(640, 480)
+        mainwindow.connect("delete_event", gtk.main_quit)
+        box1 = gtk.HBox()
+        box1.show()
+        mainwindow.add(box1)
+        box2 = gtk.VBox() # Left side panels
+        box2.show()
+        box1.pack_start(box2)
+        box3 = gtk.VBox() # Right side panels
+        box3.show()
+        box1.pack_start(box3)
+        # Create dice grid
+        self.grid = wordhuntgrid(self.size)
+        self.grid.set_size_request(250, 250)
+        for row in range(self.size):
+            for column in range(self.size):
+                self.grid.set_dice(
+                  self.dice[self.facedie[row][column]][self.face[row][column]],
+                  row,column)
+        self.grid.show()
+        box2.pack_start(self.grid)
+        # Create text entry line
+        self.word_entry = gtk.Entry()
+        self.word_entry.connect("activate", self.entry_activate_callback)
+        self.word_entry.show()
+        box2.pack_start(self.word_entry)
+        # Create timer display
+        self.timer_label = gtk.Label("1:00")
+        self.timer_label.modify_font(pango.FontDescription("mono 24"))
+        self.timer_label.set_size_request(100, 90)
+        self.timer_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(60000, 5000, 5000))
+        self.timer_label.show()
+        box3.pack_start(self.timer_label)
+        #Create Player Panel
+        self.player_panel = gtk.Label(" ")
+        self.player_panel.show()
+        self.player_panel.set_line_wrap(True)
+        self.player_panel.set_size_request(140, 100)
+        box3.pack_start(self.player_panel)
+        #Create dummy Definitions panel
+        definition_panel = gtk.Label(" ")
+        definition_panel.show()
+        box3.pack_start(definition_panel)
+        mainwindow.show()
+        self.update_timer()
+
+    def new_dice_set(self):
+        available_dice = range(16)
+        for row in range(self.size):
+            for column in range(self.size):
+                self.facedie[row][column] = random.randint(0,len(available_dice) - 1)
+                available_dice.pop(self.facedie[row][column])
+
+    def new_shuffled_group(self):
+        for row in range(self.size):
+            for column in range(self.size):
+                self.face[row][column] = random.randint(0,5)
+
+    def get_letter(self,word, index):
+        internal_index = 0
+        real_index = 0
+        if word == "":
+            return ""
+        while internal_index < index:
+            letter = word[real_index]
+            if letter == "Q":
+                real_index = real_index + 1
+                if real_index < len(word):
+                    letter = word[real_index]
+                elif letter != "U":
+                    return ""
+            real_index = real_index + 1
+            internal_index = internal_index + 1
+        result = word[real_index]
+        if result == "Q":
+            real_index = real_index + 1
+            if real_index < len(word):
+                result = result + "u"
+        return result
+
+    def start_positions(self,letter):
+        positions = []
+        for row in range(self.size):
+            for column in range(self.size):
+                if self.dice[self.facedie[row][column]][self.face[row][column]] == letter:
+                    positions.append([row, column])
+        return positions
+
+    def find_word(self,word, row, column, used):
+        matrix = [[-1, -1], [-1,0], [-1, 1],
+                  [0, -1],         [0,1],
+                  [1, -1], [1, 0], [1,1] ]
+        if word == "":
+            return []    #fin de la palabra-cerrar recursion
+        letter = self.get_letter(word,0)
+        if letter == "Qu":
+            new_word = word[2:]
+        else:
+            new_word = word[1:]
+        for transform in matrix:
+            new_row = row + transform[0]
+            new_column = column + transform[1]
+            if  new_row < 0 or new_column < 0 or \
+                 new_row > 3 or new_column > 3 or \
+                 used[new_row][new_column] == 1:
+                pass
+            elif self.dice[self.facedie[new_row][new_column]][self.face[new_row][new_column]] == letter:
+                used_copy = used
+                used_copy[new_row][new_column] = 1
+                return [[new_row, new_column]] + \
+                    self.find_word(new_word, new_row, new_column, used_copy)
+        return [False]
+
+    def word_is_valid(self,word):
+        letter = self.get_letter(word,0)
+        if letter == "":
+            return [False]
+        elif letter == "Qu":
+            new_word = word[2:]
+        else:
+            new_word = word[1:]
+        for position in self.start_positions(letter):
+            used = [[0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]]
+            used[position[0]][position[1]] = 1
+            used_copy = used
+            word_chain = [[position[0],position[1]]] + \
+                  self.find_word(new_word, position[0], position[1], used_copy)
+            if word_chain[-1] != False:
+                return word_chain
+        return [False]
+
+    def word_entered(self,word):
+        word = word.upper() #todo en mayusculas
+        if word == "X":
+            print "Adiós"
+            gtk.main_quit()
+        elif len(word) < 3:
+            self.player_panel.set_text("Demasiado Corta")
+        else:
+            word_chain = self.word_is_valid(word)
+            if word_chain[-1] != False:
+                words = ""
+                if not word in self.valid_words:
+                    self.valid_words.append(word)
+                for word in self.valid_words:
+                        words += word + ", "
+                self.player_panel.set_text(words)
+                self.mark_word(word_chain)
+            else:
+                self.player_panel.set_text("Inválida")
+
+    def entry_activate_callback(self,widget):
+        self.word_entered(self.word_entry.get_text())
+        self.word_entry.set_text("")
+        return
+
+    def mark_word(self, word_chain):
+        self.unmark_word()
+        for position in word_chain:
+            self.grid.set_color(gtk.gdk.Color(100, 100, 60000),
+                                position[0], position[1])
+        gobject.source_remove(self.highlight_timer)
+        self.highlight_timer = gobject.timeout_add(5000, self.unmark_word)
+        return
+
+    def unmark_word(self):
+        for row in range(self.size):
+            for column in range(self.size):
+                self.grid.set_color(gtk.gdk.Color(0,0,0),
+                                    row, column)
+        return False #to stop timer
+
+    def update_timer(self):
+        self.remaining_time -= 1
+        timer_text = str(int(self.remaining_time / 60)) + ":"
+        timer_text += "%0.2i" % (self.remaining_time % 60)
+        self.timer_label.set_text(timer_text)
+        if self.remaining_time == 0:
+            self.word_entry.set_state(gtk.STATE_INSENSITIVE)
+        else:
+            gobject.timeout_add(1000, self.update_timer)
+        
+
+wh = wordhunt()
+gtk.main()