Add test to evaluate complex cases

Update state update to take into account those complex cases

wordle_env/state.py

@@ -170,5 +170,8 @@ def update(state: WordleState, word: str, goal_word: str) -> Tuple[WordleState,
             elif c not in goal_word:
                 # Char at all positions = no
                 state[offset:offset + 3 * WORDLE_N] = [1, 0, 0] * WORDLE_N
+            else: # goal_word.count(c) <= processed_letters.count(c) and goal in word
+                # Only information at this point is that char at position i = no
+                state[offset + 3 * i:offset + 3 * i + 3] = [1, 0, 0]
             processed_letters.append(c)
     return state, reward

wordle_env/test_wordle.py

@@ -10,12 +10,10 @@ TESTWORDS = [
     "APAPD",
 
     "BPPAB",
-    "BPPAC",
-    "BPPAD",
-
-    "CPPAB",
-    "CPPAC",
-    "CPPAD",
+    "PPAPB",
+    "PPBBA",
+    "BPABB",
+    "PPPAC"
 ]
 
 
@@ -29,11 +27,11 @@ def wordleEnv():
 
 
 def test_reset(wordleEnv):
-    wordleEnv.reset(seed=13)
+    wordleEnv.reset()
 
 
 def test_guess_win(wordleEnv):
-    wordleEnv.reset(seed=13)
+    wordleEnv.reset()
     goal = wordleEnv.goal_word
     new_state, reward, done, _ = wordleEnv.step(goal)
     assert done
@@ -48,7 +46,7 @@ def test_guess_win(wordleEnv):
 
 
 def test_win_reward(wordleEnv):
-    wordleEnv.reset(seed=13)
+    wordleEnv.reset()
     goal = wordleEnv.goal_word
     word_index = (goal + 1) % len(wordleEnv.words)
     new_state, reward, done, _ = wordleEnv.step(word_index)
@@ -71,7 +69,7 @@ def test_win_reward(wordleEnv):
 
 
 def test_win_reward_6(wordleEnv):
-    wordleEnv.reset(seed=13)
+    wordleEnv.reset()
     goal = wordleEnv.goal_word
     random_word = (goal + 1) % len(wordleEnv.words)
 
@@ -87,7 +85,7 @@ def test_win_reward_6(wordleEnv):
 
 
 def test_lose_reward(wordleEnv):
-    wordleEnv.reset(seed=13)
+    wordleEnv.reset()
     goal = wordleEnv.goal_word
     random_word = (goal + 1) % len(wordleEnv.words)
     for i in range(1, wordleEnv.max_turns):
@@ -116,7 +114,7 @@ def letter_test(char, state, letter_state):
     assert tuple(state[offset:offset+15]) == letter_state
 
 def test_step(wordleEnv):
-    wordleEnv.reset(seed=13)
+    wordleEnv.reset()
     wordleEnv.set_goal_encoded(0)
 
     cur_state = wordleEnv.state
@@ -220,3 +218,76 @@ def test_step(wordleEnv):
     assert done
     assert wordleEnv.done
     assert reward == wordle.REWARD
+
+def test_special_step_cases(wordleEnv):
+    wordleEnv.reset()
+    wordleEnv.set_goal_encoded(4)
+    # BPPAB - goal
+    # PPAPB - 1st guess
+    new_state, _, _, _ = wordleEnv.step(5)
+    # Expect A to be all maybe except 2, 1 and 4 that are no
+    letter_state = (0, 1, 0,
+                    1, 0, 0,
+                    1, 0, 0,
+                    0, 1, 0,
+                    1, 0, 0)
+    letter_test('A', new_state, letter_state)
+    # Expect B to be all 0 except 4 that is yes and 1 that is no
+    letter_state = (0, 0, 0,
+                    1, 0, 0,
+                    0, 0, 0,
+                    0, 0, 0,
+                    0, 0, 1)
+    letter_test('B', new_state, letter_state)
+    # Expect P to be yes at 1, maybe at 2 and 4, and no in 0, 3 and 4
+    letter_state = (1, 0, 0,
+                    0, 0, 1,
+                    0, 1, 0,
+                    1, 0, 0,
+                    1, 0, 0)
+    letter_test('P', new_state, letter_state)
+    # BPPAB - goal
+    # PPAPB - 1st guess
+    # PPBBA - 2nd guess
+    new_state, _, _, _ = wordleEnv.step(6)
+    # Expect A to be all maybe except 2, 1 and 4 that are no
+    letter_state = (0, 1, 0,
+                    1, 0, 0,
+                    1, 0, 0,
+                    0, 1, 0,
+                    1, 0, 0)
+    letter_test('A', new_state, letter_state)
+    # Expect B to be maybe at 0, yes at 4, and 1 2 and 3 are no
+    letter_state = (0, 1, 0,
+                    1, 0, 0,
+                    1, 0, 0,
+                    1, 0, 0,
+                    0, 0, 1)
+    letter_test('B', new_state, letter_state)
+    # Expect P to be yes at 1, maybe at 2, and no in 0, 3 and 4
+    letter_state = (1, 0, 0,
+                    0, 0, 1,
+                    0, 1, 0,
+                    1, 0, 0,
+                    1, 0, 0)
+    letter_test('P', new_state, letter_state)
+
+    wordleEnv.reset()
+    wordleEnv.set_goal_encoded(7)
+    # BPABB - goal
+    # PPPAC - 1st guess
+    new_state, _, _, _ = wordleEnv.step(8)
+    # Expect A to be all maybe except 1 and 3 that is no
+    letter_state = (0, 1, 0,
+                    1, 0, 0,
+                    0, 1, 0,
+                    1, 0, 0,
+                    0, 1, 0)
+    letter_test('A', new_state, letter_state)
+    # Expect P to be yes at 1, maybe at 3 and 4 and no otherwise
+    letter_state = (1, 0, 0,
+                    0, 0, 1,
+                    1, 0, 0,
+                    0, 0, 0,
+                    0, 0, 0)
+    letter_test('P', new_state, letter_state)

wordle_env/wordle.py

@@ -89,7 +89,7 @@ class WordleEnvBase(gym.Env):
 
         return self.state.copy(), reward, self.done, {"goal_id": self.goal_word}
 
-    def reset(self, seed: Optional[int] = None):
+    def reset(self):
         self.state = state.new(self.max_turns)
         self.done = False
         random_word = random.choice(self.words[:self.allowable_words])