viernes, 24 de abril de 2009

Recibiendo palabras (Parte 1)

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/

No hay comentarios:

Publicar un comentario en la entrada