En este momento, nuestro juego es siempre mostrando la respuesta de adivinanza desconocida.
Es hora de que mejoremos esto.
Quiero que la retroalimentación me diga correctamente si la carta existe
y está en la posición correcta,
casi si la letra existe pero está en la posición incorrecta,
e incorrecta si la letra no existe en el mundo del día.
Creo que una gran manera para nosotros de probar este comportamiento
es tener una prueba
en el que la palabra del día es mundo y el jugador adivina mal.
Porque en este caso
las tres retroalimentaciones van a ser necesarias.
Así que echa un vistazo a esto.
Puedes ver aquí que para W, por ejemplo, debería ser correcto
porque W existe tanto en mundo como en incorrecto.
En el caso de R,
la retroalimentación debe ser casi porque aunque exista en ambos mundos,
la posición es diferente con R apareciendo en la posición 2
si tenemos en cuenta que nuestras matrices empiezan a contar en 0.
Por último, la letra N no existe en el mundo del día
y por lo tanto la respuesta debe ser incorrecta.
Para obtener la respuesta real para cada letra,
He hecho uso de la función findAll
para identificar la letra y luego con la función .at
apunté una letra en una posición específica y luego con la función .attributes
pude obtener el valor de la retroalimentación de la letra de datos de atributos.
Si ejecuto todas las pruebas, puedes ver que ahora tenemos cinco nuevas pruebas
considerando cada tipo de retroalimentación.
Como queremos centrarnos en una cosa a la vez,
vamos a saltarnos las pruebas
en las que la respuesta esperada es algo diferente de correcto.
Para ello, podemos hacer uso de de la función skipIf.
Así que puedo encadenar skipIf de la prueba y luego definir la condicional aquí.
En este caso, quiero todos los casos en los que la respuesta esperada no es correcta.
Si ahora ejecuto todas mis pruebas se puede ver que todas las otras pruebas
en las que la respuesta era diferente de la correcta
se omiten y podemos centrar nuestros esfuerzos TTG
en proporcionar la información correcta.
Bien, centrémonos en eso.
Para conseguir que esta prueba pase, la menor cantidad de trabajo que podríamos hacer
es simplemente devolver siempre la respuesta de correcto
siempre que se solicite una respuesta.
Así que si ejecutamos las pruebas de nuevo podemos ver que estamos pasando.
Impresionante. Hagamos un commit.
Esto podría ser la retroalimentación de la pantalla para las letras correctas.
No veo nada que quiera refactorizar todavía.
Así que creo que estamos en un buen punto para pasar a la siguiente batería de pruebas.
Muy bien, entonces tenemos lo correcto hecho.
Ahora quiero centrarme en la respuesta incorrecta.
Así que lo que vamos a saltar son sólo las pruebas
en las que la retroalimentación es igual a casi.
Si volvemos a realizar las pruebas
podemos ver que nuestra prueba correcta anterior sigue funcionando
y ahora tenemos dos nuevas pruebas que fallan que están relacionados con la conjetura incorrecta.
Vale, entonces para conseguir que este pase,
Siento que tenemos que empezar a hacer algunos análisis de conjeturas reales aquí.
Así que para empezar, este componente debe saber cuál es la respuesta correcta.
Así que en lugar de simplemente pasar un booleano llamado shouldFlip,
Quiero cambiar esta proposición para que diga
va a ser una proposición opcional de respuesta.
Y si una respuesta a este componente,
dará información al usuario, de lo contrario no lo hará.
La respuesta no tendrá ningún valor por defecto.
Así que si usted no proporciona una respuesta, será simplemente indefinida.
También tenemos que estar seguros de proporcionar respuesta en el WordleBoard.
Respuesta en este caso es simplemente la palabra del día.
Estupendo. Y todavía estamos en un estado fallido, por supuesto,
porque no estamos proporcionando la información incorrecta todavía.
Ahora estamos en un buen punto para hacer esto.
Es un poco difícil para mí trabajar en línea por aquí.
Así que voy a extraer una función de inmediato en este caso.
Y digamos que esta función se va a llamar getFeedback.
Y en este caso voy a pasar el índice,
función getFeedback
y lo que representa el feedback es la posición de la letra.
De acuerdo. Así que una cosa que tenemos que tener en cuenta
es que la respuesta es algo que puede que no se nos proporcione.
Así que tenemos que comprobarlo.
Si la respuesta no está definida,
Sólo voy a hacer un retorno anticipado de null.
Si las letras coinciden perfectamente, entonces devolvemos la respuesta correcta.
En caso contrario, devolvemos incorrecto.
La posición de la letra será un número.
Perfecto. Si hago las pruebas,
podemos ver que ahora estamos en una fase verde.
De acuerdo. Vamos a hacer un commit.
Y voy a llamar a este
mostrar retroalimentación para las letras incorrectas.
Para refactorizar, Creo que sería bueno para nosotros
para proporcionar algunas sugerencias de tipo para esta función de aquí.
Puede devolver null o una de las retroalimentaciones que esperamos.
Así que vamos a añadir esta pista de tipo.
Así que va a ser nulo o correcto o incorrecto.
O muy pronto, vamos a a implementar esto, casi.
Si ejecuto las pruebas, nada debería haber cambiado.
Así que estamos listos para hacer otro commit.
Añadir sugerencia de tipo.
Bien, estamos en un punto en el que por fin podemos dejar de saltarnos pruebas.
Así que voy a borrar este skipIf
llamada a la función de aquí y ejecutar las pruebas de nuevo.
Precioso. Tenemos dos nuevas pruebas que están fallando,
y todas están relacionadas con la casi retroalimentación.
Para conseguir que este pase, necesitamos volver a nuestro componente de vista de invitado.
Pero ahora vamos a cambiar nuestra implementación un poco.
Así que vamos a hacer una cláusula de protección aquí
que proporciona un retorno anticipado de incorrecto
si la letra que el usuario escribió no existe existe en absoluto en el mundo del día.
Por último, si estamos en la línea 15
sabemos a ciencia cierta que la letra al menos existe en algún lugar del mundo.
Así que si no existen exactamente en la misma posición,
entonces sabemos que la retroalimentación debe ser casi.
Si ejecutamos nuestras pruebas podemos ver que estamos pasando.
Las 32 pruebas están pasando ahora.
Asombroso. Hagamos otra confirmación.
Esta vez, Voy a decir mostrar retroalimentación
para adivinar letras casi correctas.
Por refactorización,
Creo que una buena cosa que podríamos hacer aquí para aumentar la legibilidad
es extraer constantes para la letra que el jugador adivinó
y la letra que esperamos.
Así que esto de aquí representa la letra que el jugador ha adivinado.
Así que voy a extraer esto en letterGuessed.
Finalmente, esta de aquí representa la letra esperada.
Por último, este de aquí representa la letra esperada.
Voy a mover esas dos constantes una al lado de la otra.
Y creo que eso es todo. Vamos a ejecutar la prueba de nuevo.
Y podemos ver que las pruebas siguen pasando.
Así que voy a hacer otro commit llamado extraer constantes.
Antes de terminar esta lección, quiero añadir un poco de estilo adicional.
Así que vamos a definir diferentes colores para los diferentes comentarios.
Así. Así que ya escribí esto de antemano.
Voy a pegarlo aquí.
Y se puede ver que basado en la retroalimentación,
Estoy haciendo un color de fondo diferente para la carta.
De acuerdo. Si volvemos a hacer la prueba,
de nuevo, la prueba no debería verse afectada por nuestros cambios CSS.
Así que todos pasan.
Y estamos listos para hacer otro commit.
Proporcionar colores dedicados para los diferentes tipos de feedback.
De acuerdo. Ahora hemos logrado crear un clon simple del wordle del juego
con sus requisitos protegidos por pruebas.
Por supuesto, todavía hay muchos motivos para mejorar.
Después de todo, el punto no era replicar perfectamente el juego wordle real,
sino más bien para aprender desarrollo mientras se divierten.
Nos gustaría retarte
a implementar un par de funciones más por tu cuenta.
Por ejemplo, el juego debe evitar que los jugadores adivinen repetidamente,
y también debe tener un teclado en pantalla
que muestra qué letras se han utilizado hasta ahora.
Impresionante. Y mira esto.
En una fracción de segundo,
podemos ejecutar nuestras 32 pruebas
para asegurar las reglas del juego wordle están siendo respetadas,
incluso después de refactorizar o añadir más funcionalidad a nuestra aplicación.
Estas pruebas no sólo protegen estas funcionalidades de regresiones,
sino también la documentación de lectura
para cualquiera que quiera saber de qué va nuestra aplicación.