El ingenio azucarero

Bichos

2009-05-12T09:15:00.005-05:00

El algoritmo recursivo tenía un bicho. O sea un error de programación...
Lo que sucedía es que cuando una letra tenía a su alrededor dos veces la letra siguiente de la palabra, solo aceptaba la palabra si se podía construir desde la primera. Mejor, vean esta imágen:

En este caso, la palabra "LAMI" (si existiera...) sería tomada como válida, pero la palabra "LAMP" no, porque "LAMP" usa la segunda "M" alrededor de la "A". Para corregir el error, fue necesario modificar la función find_word para que quedara así:


    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 and new_column >= 0 and \
                 new_row < 4 and new_column < 4 and \
                 used[new_row][new_column] != 1 and \
                 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
                new = self.find_word(new_word, new_row, new_column, used_copy)
                if new != [False]:
                    return [[new_row, new_column]] + new
        return [False]

Ya he hecho un commit y un push a GIT, así que el archivo completo está aquí:
http://git.sugarlabs.org/projects/wordhunt/repos/mainline/blobs/raw/e70b6bb86d4abdb34532055e948a3b0560e303e3/wordhunt.py
Hasta ahora hemos usado python y pygtk, que son requerimientos para hacer una actividad para Sugar, pero aún no es una actividad exclusivamente de Sugar. Lo que llevamos puede correr sin problema en cuaquier sistema que tenga python y pygtk. A partir de la próxima entrada usaremos Sugar (finalmente!).
Imágen:
e3000: http://www.flickr.com/photos/e3000/2480983620/

Dando un hogar al código

2009-05-09T08:10:00.000-05:00

Como dije en la anterior entrada, es la última vez que pongo el código en el blog.
Esto no quiere decir que no habrá más código...
Como el código se está haciendo largo y complejo, se hace necesario partirlo en varios archivos y darles luego un hogar para que vivan su vida de código.
Seguramente se han preguntado por qué he usado variables y escrito los comentarios en inglés, si estoy haciendo esta actividad en español... La razón es que como voy a compartir mi actividad con otros desarrolladores, y es posible que en algún momento tengan que modificar mi actividad, lo más práctico es tenerla en inglés para que la mayoría de los desarrolladores (que hablan casi todos inglés) puedan hacerlo.
SugarLabs tiene un servicio muy práctico para alojar código, que permite a cualquier persona, de forma muy sencilla alojar su código en los servidores de SugarLabs.
El código de computadores usualmente se aloja no como páginas o texto normal de Internet sino usando un Sistema de control de versiones, que permite a diferentes personas acceder, modificar y revisar el código, pudiendo ver los cambios históricos que se han hecho a cada archivo. SugarLabs usa un sistema de control de versiones llamado GIT, y un portal web que hace de interfaz a GIT llamado gitorious.
Las fuentes alojadas en SugarLabs se encuentran en: http://git.sugarlabs.org/. Aquí podemos consultar la información sobre proyectos, actividades y desarrolladores. Podemos, por ejemplo, buscar proyectos para ver su estado y podemos visitar el portal de actividades desde el que se pueden bajar actividades para Sugar.

Creando nuestro proyecto en SugarLabs
Un repositorio es un lugar donde podemos alojar nuestras fuentes. Crear nuestro repositorio en SugarLabs es sencillo, pero hay que seguir una serie de pasos. Primero debemos crear una cuenta en SugarLabs. Cuando hayamos entrado nuestros datos en el formulario, recibiremos un email de de Gitorious y nuestra cuenta quedará activada cuando sigamos el enlace proporcionado en el email.
Yo ya tengo el mío aquí: Wordhunt.
Para poder garantizar la seguridad y autenticar la identidad de las personas que modifican el código, es necesario crear unas llaves de seguridad SSH. Para esto podemos usar OpenSSH. Hay bastantes tutoriales en Internet que explican la creación de llaves como este.
Una vez hemos creado nuestro par de llaves, debemos agregar la llave pública (la llave privada nunca debe salir de nuestras manos!) yendo a nuestro perfil dentro de SugarLabs y seleccionando "Add SSH key".
Una vez tenemos una llave dentro de SugarLabs, ya podemos crear nuestro proyecto. Para hacerlo, vamos a gitorious y seleccionamos "Project" en la barra superior. Este enlace nos lleva a una lista de proyectos. En esta página hay un enlace para crear nuevo proyecto. Aquí damos nombre a nuestro proyecto y otros datos como las categorías, la descripción y la licencia de nuestro proyecto. Cuando pulsemos el botón inferior "Create project", habremos creado un proyecto en SugarLabs.

Usando GIT
No haré una introducción ni una explicación de GIT aquí, ya que es largo y complejo, pero si explicaré los pasos que se deben seguir para usar git con los repositorios de SugarLabs. Asumo tambiémn que ya está instalado git (que para distribuciones de GNU/Linux, está en los repositorios oficiales).
Lo primero de debemos hacer es crear una carpeta en nuestro equipo donde tendremos nuestro código fuente. Usando una terminal cambio al directorio de mis fuentes y doy:


git init

Esto prepara mi repositorio local (aunque aún esté vacío...)
Luego conecto mi repositorio local con mi nuevo repositorio remoto con esta línea:


git remote add origin gitorious@git.sugarlabs.org:wordhunt/mainline.git
git push origin master

Naturalmente hay que cambiar "wordhunt" por el nombre del proyecto y "gitorious" por nuestro nombre en SugarLabs.
Ya podemos subir las fuentes, así que creamos el archivo wordhunt.py en nuestra carpeta, y para añadirlo al repositorio hacemos:


git add wordhunt.py

Para aprobar nuestros cambios hacemos:


git commit -a

Lo que abrirá un editor para que entremos un comentario acerca de los cambios hechos. Y finalmente para empujar nuestros cambios al servidor hacemos:


git push

Naturalmente usar git es complicado y tiene muchas sutilezas, pero para nuestro sencillo proyecto, lo que debemos hacer cada vez que queramos subir y actualizar nuestras fuentes hacemos un git add para los archivos que aún no han sido agregados, luego un git commit y un git push, que actualizará todos los archivos.
Pueden ver que ya tengo en SugarLabs mi archivo wordhunt.py. Si quieren poder copiar y pegar a un editor sin los números de línea pueden seguir en esta página el enlace que dice "raw blob data", o sea éste

Imágen:
Unhindered by Talent: http://www.flickr.com/photos/nicmcphee/656666358/

Contando

2009-05-06T20:59:00.004-05:00

Ahora vamos a descongelar el tiempo... Vamos a hacer que el contador se mueva y que el juego termine cuando el tiempo se acabe. Para este tipo de labores, es ideal la función timeout_add del módulo gobject. Esta función espera cierto tiempo, y luego ejecuta una segunda función, entonces lo que hacemos es definir una función que cuando sea llamada, reste uno del tiempo restante (remaining_time), y actualice el tiempo que se muestra en la interfaz. Además, vuelve a crear un contador de tiempo que vuelve a llamar esta función cuando haya pasado un segundo (1000 milisegundos). De esta forma, tendremos un contador. Cuando el tiempo llegue a 0, la casilla de entrada de texto es bloqueada para que no se pueda entrar más palabras.


    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)
        return False

Además de importar el módulo gobject al inicio para poder usar el contador:


import gobject

al final de la función __init__ que ya tenemos (llamada el constructor), llamamos una vez la función update_timer para que el contador empiece a contar:


        self.update_timer()

También voy a aprovechar para ir acumulando las palabras correctas en una lista (valid_words), e iré mostrando las palabras que ha entrado el jugador. Esto lo hago cada vez que se entra una palabra válida (dentro de la función word_entered). Es importante revisar que la palabra entrada no esté contenida en las palabras váidas que ya tengo, para no incluirla dos veces en la lista.


    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 valid_word in self.valid_words:
                    words += valid_word + ", "
                self.player_panel.set_text(words)
                self.mark_word(word_chain)
            else:
                self.player_panel.set_text("Inválida")

Ah! Además puedo aprovechar para mostrar dónde está ubicada la palabra con la nueva función mark_word. Esta función marca en azul las letras que forman la palabra. Lo que debo hacer es recorrer las posiciones de la palabra e ir cambiando el color del gtk.Label de esa posición. Además quiero que dure marcada 5 segundos, pero que luego se desmarque automáticamente. Para esto activo un contador que llame la función unmark_word que se encarga de dejar todas las letras negras otra vez. Es importante cancelar el contador de la palabra anterior para garantizar que siempre dura 5 segundos marcada la palabra con la función source_remove de gobject.


    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

La función unmark_word se ve así:


    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

Y listo, cada vez se siente más funcional el juego. Como siempre, y por última vez aquí está el código:


#! /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 valid_word in self.valid_words:
                    words += valid_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)
        return False

wh = wordhunt()
gtk.main()

Imágen:
wwarby: http://www.flickr.com/photos/wwarby/3297205226/

Mezclando

2009-05-03T11:01:00.012-05:00

Vamos ahora a mezclar los ingredientes que tenemos. Por un lado habíamos construido el motor del juego, que puede generar la matriz de dados aleatoriamente, y que puede recibir las palabras escritas por el jugador para verificar si se pueden construir con los dados disponibles. De este ingrediente, ya no necesitaremos la función que imprime en la terminal la cuadrícula, ni la entrada de texto desde la terminal, porque esto será ahora el trabajo de nuestro segundo ingrediente. Nuestro segundo ingrediente fue la interfaz gráfica, que nos puede mostrar la cuadrícula, además de tener un espacio para entrar texto. Vamos a agregar un par de cosas a la clase worhuntgrid:


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)

En primer lugar, agrego la opción de determinar el tamaño de la cuadrícula cuando se cree el objeto, por eso ahora el constructor (__init__) toma un valor de entrada. Este valor se guarda en la variable self.size. El objeto self representa al objeto mismo en el que estamos, así que self.size es la variable size que pertence al objeto. No es la misma size que entró al objeto. Además he agregado una función set_dice, que permite dar una letra (text) y su ubicación para colocarla en la cuadrícula.

Y ahora si a mezclar...

Para combinar el motor del programa con su interfaz gráfica, voy a crear una clase llamada wordhunt. Esta clase contendrá elementos de ambos, muchas veces colocando self como prefijo a algunas variables, para que éstas estén disponibles para el resto de funciones de la clase. Naturalmente cuando las use, debo usar también el prefijo self.
Para pasar las letras de los dados que se generaron aleatoriamente, debo usar la función set_dice que mostré arriba de esta forma:


        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)

Para recibir la entrada de texto, debo monitorear el momento en que se ha hecho "Enter" en la entrada de texto. Muchos objetos en GTK generan "señales" cuando ocurre algo con ellos. Un objeto gtk.Entry genera una señal "activate" cuando se presiona "Enter" estando el cursor en él. Lo que debemos hacer es conectar esta señal a una función (entry_activate_callback), que será llamada cada vez que la señal se genere, así:


        self.word_entry.connect("activate", self.entry_activate_callback)

La función que se llama con activate la defino así:


    def entry_activate_callback(self,widget):
        self.word_entered(self.word_entry.get_text())
        self.word_entry.set_text("")
        return

Esta función llama a una segunda función (word_entered), pasándole el contenido de la entrada de texto, y luego limpia la entrada de texto. Además, en vez de usar print como antes para reportar si una palabra es válida, pongo el texto en el gtk.Label player_panel. De esta forma el texto se muestra justo debajo del contador de tiempo. La función word_entered queda así:


#! /usr/bin/env python
# -*- coding: utf-8 -*-

import gtk
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)

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()
        mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
        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
        timer_label = gtk.Label("1:00")
        timer_label.modify_font(pango.FontDescription("mono 24"))
        timer_label.set_size_request(100, 90)
        timer_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(60000, 5000, 5000))
        timer_label.show()
        box3.pack_start(timer_label)
        #Create Player Panel
        self.player_panel = gtk.Label(" ")
        self.player_panel.show()
        box3.pack_start(self.player_panel)
        #Create dummy Definitions panel
        definition_panel = gtk.Label(" ")
        definition_panel.show()
        box3.pack_start(definition_panel)
        mainwindow.show()

    def new_dice_set(self):
        available_dice = range(16)
        for row in range(4):
            for column in range(4):
                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(4):
            for column in range(4):
                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(4):
            for column in range(4):
                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:
                self.player_panel.set_text("Válida")
                print 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

wh = wordhunt()
gtk.main()

Imágenes:

vivere libero: http://www.flickr.com/photos/viverelibero/3004553146/
sylvar: http://www.flickr.com/photos/sylvar/348629926/
ginnerobot: http://www.flickr.com/photos/ginnerobot/3156850244/
_e.t: http://www.flickr.com/photos
/45688285@N00/82172576/
mknobil: http://www.flickr.com/photos/knobil/163202136/

Iniciando la interfaz gráfica (Parte 2)

2009-04-30T22:59:00.007-05:00

En este artículo, agregaré un par de nuevos elementos a la interfaz para dejarla prácticamente completa. Hay que tener en cuenta que aún no he entrado en Sugar, estoy usando aún sólo GTK. Esto tiene la ventaja de que aún podemos correr el programa en equipos sin Sugar, pero aún no tenemos funcionalidad de sugar como la barra superior de la actividad o la posibilidad de integrar nuestra aplicación con el Diario de Sugar.
En la entrada anteriror, mostré cómo hacer la cuadrícula de letras y cómo ponerla dentro de una ventana GTK. Ahora que voy a colocar otros elementos como el contador y la entrada de texto, es necesario usar "Contenedores" de GTK. Los contenedores son "objetos" que me permiten colocar otros "objetos" dentro de ellos. Como en una repisa, puedo tener varias divisiones para poner elementos. Para construir la interfaz, usaré los contenedores gtk.VBox y gtk.HBox que son contenedores con espacios alineados vertical u horizontalmente respectivamente.
Primero usaré un HBox para partir la ventana en dos partes. En la izquierda voy a tener los dados y la línea de entrada de texto, y en la derecha, tendré el contador y la información de las palabras. El HBox me crea un contenedor (que llamo box1) con elementos alineados uno al lado del otro. Luego con un VBox (que llamo box2) que colocaré dentro del HBox (usando la función pack_start), podré colocar la cuadrícula sobre la entrada de texto:


mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
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
grid = wordhuntgrid()
grid.set_size_request(250, 250)
grid.show()
box2.pack_start(grid)
# Create text entry line
word_entry = gtk.Entry()
word_entry.show()
box2.pack_start(word_entry)

Finalmente en otra caja vertical (box3), pondré el contador y otros dos elementos de texto vacíos de los que me encargaré en otra ocasión:


# Create timer display
timer_label = gtk.Label("1:00")
timer_label.modify_font(pango.FontDescription("mono 24"))
timer_label.set_size_request(100, 90)
timer_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(60000, 5000, 5000))
timer_label.show()
box3.pack_start(timer_label)
#Create dummy Player Panel
player_panel = gtk.Label(" ")
player_panel.show()
box3.pack_start(player_panel)
#Create dummy Definitions panel
definition_panel = gtk.Label(" ")
definition_panel.show()
box3.pack_start(definition_panel)
mainwindow.show()
gtk.main()

Con este sencillo código ya tengo una ventana que se ve así en Ubuntu (Gnome):

Y así en Sugar:

Y como es usual, el código:


#! /usr/bin/env python
# -*- coding: utf-8 -*-

# GTK es la librería gráfica usada por Sugar
import gtk

# Pango es una librería para el dibujo de texto internacional
import pango

class wordhuntgrid(gtk.Table):
    def __init__(self):
        self.size = 4
        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]

mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
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
grid = wordhuntgrid()
grid.set_size_request(250, 250)
grid.show()
box2.pack_start(grid)
# Create text entry line
word_entry = gtk.Entry()
word_entry.show()
box2.pack_start(word_entry)
# Create timer display
timer_label = gtk.Label("1:00")
timer_label.modify_font(pango.FontDescription("mono 24"))
timer_label.set_size_request(100, 90)
timer_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.Color(60000, 5000, 5000))
timer_label.show()
box3.pack_start(timer_label)
#Create dummy Player Panel
player_panel = gtk.Label(" ")
player_panel.show()
box3.pack_start(player_panel)
#Create dummy Definitions panel
definition_panel = gtk.Label(" ")
definition_panel.show()
box3.pack_start(definition_panel)
mainwindow.show()
gtk.main()

Imágen:
mark sebastian: http://www.flickr.com/photos/markjsebastian/210573715/

Iniciando la interfaz gráfica (Parte 1)

2009-04-28T21:43:00.016-05:00

Ya tenemos una parte del motor interno de nuestro juego. Ahora, debemos presentar nuestro juego dentro de una ventana propia con todos los elementos necesarios visibles. Las ventanas además de presentar información, son el tablero de control de nuestro juego.
Como eso de usar ventanas, botones y menus es tan común, los programadores no tenemos que hacer todo el trabajo. Existen muchas herramientas libres (y que además pueden usarse desde de Python) para esto. Sugar en particular usa la biblioteca GTK, así que empezaremos a construir nuestra interfaz gráfica con ella. Para esto es necesario importar en python el módulo gtk:


import gtk

Además voy a usar Pango, que se encarga del formato y dibujo del texto. Por ahora solo lo usaré para cambiar de tamaño mis letras. Debo cargar el módulo pango con:


import pango

Antes de empezar a escribir código, he hecho un simple boceto de lo que quiero tener:
En este dibujo se ve la cuadrícula de los dados en la izquierda y una línea de entrada de texto debajo de ésta. En la derecha de la interfaz gráfica, tendremos el tiempo de juego, las palabras entradas por los jugadores (cuando logremos llegar a compartir la actividad), y abajo un panel para mostrar la definición de la palabra seleccionada (posiblemente traída de internet para no tener que empacar un diccionario completo con nuestro juego).
Además, en la barra superior habrá dos pestañas, una de "Actividad", que permite iniciar el juego, y determinar el tiempo de juego, y otra pestaña que permite ver los puntajes.
En esta entrada simplemente vamos a crear la cuadrícula de los dados.
Para hacer esta cuadrícula, voy a crear una clase que hereda la clase gtk.Table. Es decir es una tabla, con algunas características adicionales.
En cada una de las 16 casillas coloco (con la función attach) un gtk.Label que mostrará la letra (por ahora solo una "A"), y los guardaré en una lista (dice_labels) para poder manipuarlos después.


# GTK es la librería gráfica usada por Sugar
import gtk

# Pango es una librería para el dibujo de texto internacional
import pango

class wordhuntgrid(gtk.Table):
   def __init__(self):
       self.size = 4
       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]

Hemos creado aquí una clase que puede mostrarse, pero hasta que no la instanciemos, es un cascarón vacío...
Lo que haremos es crear una ventana (mainwindow) y luego agregamos nuestra cuadrícula (guardada en la variable grid)


mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
grid = wordhuntgrid()
mainwindow.add(grid)
grid.set_size_request(250, 250)
grid.show()
mainwindow.show()
mainwindow.connect("delete_event", gtk.main_quit)
gtk.main()

Esta parte eventualmente cambiará radicalmente, pero por ahora es útil para ver cómo funciona nuestra cuadrícula.
En Sugar todas las ventanas ocupan la pantalla completa y no tienen borde por defecto, por eso para cerrar el programa, es necesario usar las teclas "Alt"+ "Esc" al mismo tiempo (el "Esc" en una máquina XO es la X en la esquina superior izquierda).
Y ahora como siempre al final el código:


# GTK es la librería gráfica usada por Sugar
import gtk

# Pango es una librería para el dibujo de texto internacional
import pango

class wordhuntgrid(gtk.Table):
   def __init__(self):
       self.size = 4
       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]

mainwindow = gtk.Window(gtk.WINDOW_TOPLEVEL)
grid = wordhuntgrid()
mainwindow.add(grid)
grid.set_size_request(250, 250)
grid.show()
mainwindow.show()
mainwindow.connect("delete_event", gtk.main_quit)
gtk.main()

Enlaces

Tutorial de pygtk

Imágenes

internets diary:http://www.flickr.com/photos/16339684@N00/2361897135/

Recibiendo palabras (Parte 2)

2009-04-27T21:59:00.012-05:00

Ahora que podemos recibir las palabras entradas por el jugador, el computador debe revisar si la palabra se puede construir con las letras disponibles. ¡Este tipo de cálculos son la razón de existir de los computadores!
Para averiguar si una palabra se encuentra, tenemos que revisar primero si la primera letra está disponible. Además, debemos tratar de formar la palabra a partir de cada aparición de la letra, es decir debemos repetir el proceso para cada vez que la letra se encuentre. Para esto se escribí la función start_positions, que busca entre los dados las ubicaciones de la letra, y entrega la lista de coordenadas en las que se encuentra. Entrega una lista vacía si la letra no se encuentra.

def start_positions(letter):
 positions = []
    for row in range(4):
     for column in range(4):
         if dice[facedie[row][column]][face[row][column]] == letter:
             positions.append([row, column])
    return positions

Para mejorar un poco la interacción, modifico el ciclo principal para que muestre los dados después de cada intento. Este es un execelente ejemplo de lo que sucede en un proceso de desarrollo, al necesitar afinar la interacción a partir de la evaluación del uso real. Además, como la función word_is_valid ahora entregará la lista de coordenadas de la palabra formada, entonces para saber si la palabra fue encontrada, tenemos que revisar el último elemento de la lista.

while True:
 print_face()
 word = raw_input(">")
 word = word.upper() #todo en mayusculas
 if word == "X":
     print "Adiós"
     break
 elif len(word) < 3:
     print "Demasiado Corta"
 else:
     word_chain = word_is_valid(word)
     if word_chain[-1] != False:
         print "Válida", word_chain
     else:
         print "Inválida"

Ahora si, pasemos a la pulpa...
El proceso de encontrar la palabra consiste en a partir de la primera letra, buscar la siguiente en las casillas adyacentes, teniendo en cuenta de no buscar en casillas que no existen y sobretodo teniendo en cuenta no usar letras que ya han sido usadas. Si entre las adyacentes encontramos la siguiente letra, pasamos a esta y repetimos el mismo proceso de buscar en las adyacentes hasta que se han acabado las letras de la palabra. Si las letras se acaban y hemos logrado encontrarlas todas en línea, quiere decir que la palabra existe. Si alguna letra no la encontramos, debemos ir hacia atrás para buscar otras posibilidades. Este tipo de procesos son ideales para ser modelados en código por medio de recursión. la recursión es el proceso de llamar la función desde ella misma, hasta que alguna condición permita terminar la cadena. La función find_word es una función recursiva, que se llama a si misma mientras la palabra tenga letras. Cuando la llamamos, no le entrego la palabra completa, sino el pedazo de la palabra que falta por encontrar. De esta forma, si se han acabado las letras, sabremos que la palabra fue encontrada.
Para buscar en las casillas adyacentes, uso la matriz matrix que guarda las coordenadas relativas a la casilla. Recorro cada una de ellas en un ciclo (cada elemento es la variable transform), y en este ciclo, si la letra es encontrada, llamo recursivamente find_word.

def find_word(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 = 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 dice[facedie[new_row][new_column]][face[new_row][new_column]] == letter:
         used_copy = used
         used_copy[new_row][new_column] = 1
         return [[new_row, new_column]] + \
             find_word(new_word, new_row, new_column, used_copy)
 return [False]

Ya se puede ver en esta función un problema que surge de la existencia de la letra "Qu". En los dados , puede salir la letra "Qu" que debe contarse como una sola letra a pesar de contener dos letras. Esto implica que en todas las palabras que se entren la palabra es inválida si hay una "q" a la que no le sigue un "u", y además que cuando aparezca "qu" debemos tratarla como una sola letra.
Finalmente, hay que hacer algunas adiciones a la función word_is_valid para que busque la primera letra de la palabra, y a partir de esta inicie la recursion con la función find_word.

def word_is_valid(word):
  letter = get_letter(word,0)
  if letter == "":
      return [False]
  elif letter == "Qu":
      new_word = word[2:]
  else:
      new_word = word[1:]
  for position in 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]]] + \
              find_word(new_word, position[0], position[1], used_copy)
      if word_chain[-1] != False:
          return word_chain
  return [False]

Y listo por ahora... En la próxima empezaremos a crear la interfaz visual para nuestro programa (además de buscar un pequeño error que hace que algunas veces no se detecte la palabra correctamente....)
Como siempre aquí está el código:


import random

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"] ]

face = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]
facedie = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]

def new_dice_set():
  available_dice = range(16)
  for row in range(4):
      for column in range(4):
          facedie[row][column] = random.randint(0,len(available_dice) - 1)
          available_dice.pop(facedie[row][column])

def new_shuffled_group():
  for row in range(4):
      for column in range(4):
          face[row][column] = random.randint(0,5)

def print_face():
  for row in range(4):
      for column in range(4):
          print dice[facedie[row][column]][face[row][column]], " ",
      print ""

def get_letter(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(letter):
  positions = []
  for row in range(4):
      for column in range(4):
          if dice[facedie[row][column]][face[row][column]] == letter:
              positions.append([row, column])
  return positions

def find_word(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 = 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 dice[facedie[new_row][new_column]][face[new_row][new_column]] == letter:
          used_copy = used
          used_copy[new_row][new_column] = 1
          return [[new_row, new_column]] + \
              find_word(new_word, new_row, new_column, used_copy)
  return [False]

def word_is_valid(word):
  letter = get_letter(word,0)
  if letter == "":
      return [False]
  elif letter == "Qu":
      new_word = word[2:]
  else:
      new_word = word[1:]
  for position in 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]]] + \
              find_word(new_word, position[0], position[1], used_copy)
      if word_chain[-1] != False:
          return word_chain
  return [False]

new_shuffled_group()
new_dice_set()

while True:
  print_face()
  word = raw_input(">")
  word = word.upper() #todo en mayusculas
  if word == "X":
      print "Adiós"
      break
  elif len(word) < 3:
      print "Demasiado Corta"
  else:
      word_chain = word_is_valid(word)
      if word_chain[-1] != False:
          print "Válida", word_chain
      else:
          print "Inválida"

Imágenes

sergis blog: http://www.flickr.com/photos/srgblog/2772659768/
brew books http://www.flickr.com/photos/brewbooks/3318600273/
Quinn-S: http://www.flickr.com/photos/q-shan/3205236312/

Recibiendo palabras (Parte 1)

2009-04-24T07:36:00.010-05:00

Ahora que tenemos listos los dados para jugar, necesitamos al jugador...

El jugador debe poder entrar las palabras al computador con el teclado. Para esto podemos usar un ciclo "while" que permite al jugador entrar palabras hasta que se canse y entre la letra "x":

while True:
  word = raw_input(">")
  word = word.upper() #todo en mayusculas
  if word == "X":
      print "Adiós"
      break
  elif len(word) < 3:
      print "Demasiado Corta"
  elif word_is_valid(word):
      print "Palabra válida"
  else:
      print "No válida"

Como ven, uso la función raw_input y luego convierto todas las letras a mayúsculas usando upper().
Luego reviso si se entró la letra "X" para terminar o si la palabra tiene menos de 3 letras, lo que la hace demasiado corta para el juego. Si la palabra pasa estas pruebas, es necesario luego revisar si se puede formar con los dados, para lo que defino la función word_is_valid. Esta función es la primera de nuestro programa que usa return para devolver un valor a quien la llama. Lo que hace es evaluar la palabra y da el veredicto de si es válida o no. Además esta función recibe un "argumento", es decir, al llamarla, debemos entregarle una información para que trabaje. En este caso, la información es la palabra a evaluar:

def word_is_valid(word):
 letter = get_letter(word,0)
 if letter == "":
     return False
 for row in range(4):
     for column in range(4):
         used = [[0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]]
         if dice[facedie[row][column]][face[row][column]] == letter:
             print "Encontrada ", row, column
 return True

Por ahora esta función solo revisa si la primera letra de la palabra se encuentra entre los dados, y reporta si lo está (Esta función la completaré en la parte 2 de este artículo).
En este momento surge un problema complicado, que resulta del hecho que el dado que tiene la "Q" está marcado "Qu", es decir, la Q siempre viene seguida de una U. Por esto la Q seguida de U debe contarse como una sola letra, a pesar de ser en realidad dos. Además se deben declarar inválidas las palabras que tengan una Q que no está seguida por una U, porque no es posible hacerlas con los dados. Para esto creo la función get_letter, que me permite averiguar las letras de la palabra, contando la "QU" como una sola letra:

def get_letter(word, index):
   if index > len(word):
       return ""
   internal_index = 0
   real_index = 0
   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

A esta función debo entregarle la palabra y el número de la letra que quiero averiguar (la primera se considera la letra 0). Esta función retorna la letra correspondiente a la posición que se pide o ninguna letra ("") si hay algún problema, como que se pidió una casilla que no existe o si hay una Q sin U.
En la segunda parte completaré la función word_is_valid para que busque entre los dados la palabra del jugador (Como está el programa todas las palabras las reporta como válidas!). Al unir lo que acabo de mostrar con nuestro programa anterior, tenemos:

import random

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"] ]

face = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]
facedie = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]

def new_dice_set():
   available_dice = range(16)
   for row in range(4):
       for column in range(4):
           facedie[row][column] = random.randint(0,len(available_dice) - 1)
           available_dice.pop(facedie[row][column])

def new_shuffled_group():
   for row in range(4):
       for column in range(4):
           face[row][column] = random.randint(0,5)

def print_face():
   for row in range(4):
       for column in range(4):
           print dice[facedie[row][column]][face[row][column]], " ",
       print ""

def get_letter(word, index):
   if index > len(word):
       return ""
   internal_index = 0
   real_index = 0
   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 word_is_valid(word):
    letter = get_letter(word,0)
    if letter == "":
        return False
    for row in range(4):
        for column in range(4):
            used = [[0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0]]
            if dice[facedie[row][column]][face[row][column]] == letter:
                print "Encontrada ", row, column
    return True

new_shuffled_group()
new_dice_set()
print_face()

while True:
    word = raw_input(">")
   word = word.upper() #todo en mayusculas
   if word == "X":
       print "Adiós"
       break
   elif len(word) < 3:
       print "Demasiado Corta"
   elif word_is_valid(word):
       print "Palabra válida"
   else:
       print "No válida"

Imágenes

Ross Angus: http://www.flickr.com/photos/ross_angus/483602549/
J.Smith831: http://www.flickr.com/photos/29814869@N07/2801793552/
Karen Horton: http://www.flickr.com/photos/karenhorton/1583519788/

Barajando los dados

2009-04-22T17:05:00.006-05:00

Hay que empezar por el principio.

Antes de entrar en las gráficas y mecanismos del juego como el conteo del tiempo y la revisión de palabras, hay que crear los dados. Para esto, vamos a guardarlos en una lista de Python. Una lista es simplemente eso, un lugar que guarda un elemento tras otro. Cada uno de los 16 dados es una lista de sus seis lados, por ejemplo:

["T", "O", "E", "S", "S", "I"]

(Explicaré el código por partes y al final está el código completo)

Podemos tener una sola variable que contenga todos los dados. Esta sería una lista que contiene 16 listas así:

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"] ]

Ahora que ya tenemos dados, necesitamos una cuadrícula para poner los dados. Para esto también podemos crear listas.
Lo que haré es tener dos cuadrículas de 4 por 4. Una contendrá el número del dado que está en esa posición y la otra contiene el número del lado del dado que está visible:

face = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]
facedie = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]

Ahora crearé una función para colocar los dados en una posición. Como no se puede repetir un dado, creo una lista llamada "available_dice", en la que guardo los números de 0 a 15, para cuando salga un dado quitarlo de la lista. Luego para cada posición (row, column) de la lista "facedie", selecciono al azar que dado queda en esa casilla así:

def new_dice_set():
   available_dice = range(16)
   for row in range(4):
       for column in range(4):
           facedie[row][column] = random.randint(0,len(available_dice) - 1)
           available_dice.pop(facedie[row][column])

Luego hago algo similar con los lados. Para cada casilla, "lanzo" el dado, para que quede uno de sus lados al azar. En la lista "face" guardo el lado visible en cada una de las casillas:

def new_shuffled_group():
   for row in range(4):
       for column in range(4):
           face[row][column] = random.randint(0,5)

Listo, con esto tenemos la cajita y los dados. ¡Pero aún no los vemos!
Para terminar por ahora haré una sencilla función que muestre los dados en la pantalla, y llamaré las funciones anteriores:

def print_face():
   for row in range(4):
       for column in range(4):
           print dice[facedie[row][column]][face[row][column]], " ",
       print ""

new_shuffled_group()
new_dice_set()
print_face()

Ya debes poder ver algo como:

T   B   P   K
X   Y   E   O
M   U   K   N
P   I   E   E

Nos vemos en la próxima. Aquí está el código completo:

import random

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"] ]

face = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]
facedie = [ [0,0,0,0], [0,0,0,0], [0,0,0,0], [0,0,0,0] ]

def new_dice_set():
   available_dice = range(16)
   for row in range(4):
       for column in range(4):
           facedie[row][column] = random.randint(0,len(available_dice) - 1)
           available_dice.pop(facedie[row][column])

def new_shuffled_group():
   for row in range(4):
       for column in range(4):
           face[row][column] = random.randint(0,5)

def print_face():
   for row in range(4):
       for column in range(4):
           print dice[facedie[row][column]][face[row][column]], " ",
       print ""


new_shuffled_group()
new_dice_set()
print_face()

Fuentes
Blog de Matthew James Taylor: De este blog tomé el contenido de los dados.
Créditos Imágenes

topher76: http://www.flickr.com/photos/topher76/293277608/
Andrés Rueda: http://farm3.static.flickr.com/2086/2347555407_2b10ccb272.jpg?v=0
tanakawho: http://www.flickr.com/photos/28481088@N00/2299815836/

Iniciando el juego "Caza Palabras"

2009-04-22T15:54:00.001-05:00

He decido iniciar el desarrollo de un juego sencillo y documentar el proceso para desentrañar los misterios de Sugar (Nada mejor que explicar un tema mientras se aprende para asegurarse que se entendió...)
Quiero hacer un juego basado en Boggle. Este juego consiste en encontrar palabras en una cuadrícula de 4x4, que contiene dados con letras.
Iré contando paso a paso los detalles de la construcción, y espero llegar a terminarlo...
¿Qué se necesita para seguir el desarrollo? Sólo un editor de texto para escribirlo y Python, el lenguaje de programación para correrlo. En un XO, se puede usar Pippy.

(Foto por squacco: http://www.flickr.com/photos/squeakywheel/505768192/ Licencia CC-BY-SA)

Bienvenidos al ingenio azucarero

2009-03-23T07:19:00.000-05:00

Hola,

En este blog documentaré mis experiencias desarrollando para la la plataforma Sugar (Azucar).

Este blog asume que ya tienes Python instalado, y que tienes algún conocimiento de programación en Python. Existen muchas introducciones a Python circulando en Internet, por ejemplo:

Si tienes preguntas o comentarios, anímate y pregunta!

Saludos,
Andrés