Get score from game progression if available

Author: MarcCote

textworld/envs/glulx/git_glulx_ml.py

@@ -89,7 +89,7 @@ def _detect_i7_events_debug_tags(text: str) -> Tuple[List[str], str]:
     """
     matches = []
     open_tags = []
-    for match in re.findall("\[[^]]+\]\n?", text):
+    for match in re.findall(r"\[[^]]+\]\n?", text):
         text = text.replace(match, "")  # Remove i7 debug tags.
         tag_name = match.strip()[1:-1]  # Strip starting '[' and trailing ']'.
 
@@ -127,8 +127,6 @@ def __init__(self, *args, **kwargs):
         :param kwargs: The kwargs
         """
         super().__init__(*args, **kwargs)
-        self._has_won = False
-        self._has_lost = False
         self.has_timeout = False
         self._state_tracking = False
         self._compute_intermediate_reward = False
@@ -153,7 +151,7 @@ def init(self, output: str, game: Game,
         self._compute_intermediate_reward = compute_intermediate_reward and len(game.quests) > 0
         self._objective = game.objective
         self._score = 0
-        self._max_score = sum(quest.reward for quest in game.quests)
+        self._max_score = self._game_progression.max_score
 
     def view(self) -> "GlulxGameState":
         """
@@ -218,12 +216,6 @@ def update(self, command: str, output: str) -> "GlulxGameState":
                     # An action that affects the state of the game.
                     game_state._game_progression.update(game_state._action)
 
-                if game_state._compute_intermediate_reward:
-                    if game_state._game_progression.winning_policy is None:
-                        game_state._has_lost = True
-                    elif len(game_state._game_progression.winning_policy) == 0:
-                        game_state._has_won = True
-
         return game_state
 
     @property
@@ -321,18 +313,22 @@ def intermediate_reward(self):
     @property
     def score(self):
         if not hasattr(self, "_score"):
-            # Check if there was any Inform7 events.
-            if self._feedback == self._raw:
-                self._score = self.previous_state.score
+            if self._state_tracking:
+                self._score = self._game_progression.score
             else:
-                output = self._raw
-                if not self.game_ended:
-                    output = self._env._send("score")
 
-                match = re.search("scored (?P<score>[0-9]+) out of a possible (?P<max_score>[0-9]+),", output)
-                self._score = 0
-                if match:
-                    self._score = int(match.groupdict()["score"])
+                # Check if there was any Inform7 events.
+                if self._feedback == self._raw:
+                    self._score = self.previous_state.score
+                else:
+                    output = self._raw
+                    if not self.game_ended:
+                        output = self._env._send("score")
+
+                    match = re.search("scored (?P<score>[0-9]+) out of a possible (?P<max_score>[0-9]+),", output)
+                    self._score = 0
+                    if match:
+                        self._score = int(match.groupdict()["score"])
 
         return self._score
 
@@ -342,11 +338,23 @@ def max_score(self):
 
     @property
     def has_won(self):
-        return self._has_won or '*** The End ***' in self.feedback
+        if not hasattr(self, "_has_won"):
+            if self._compute_intermediate_reward:
+                self._has_won = self._game_progression.completed
+            else:
+                self._has_won = '*** The End ***' in self.feedback
+
+        return self._has_won
 
     @property
     def has_lost(self):
-        return self._has_lost or '*** You lost! ***' in self.feedback
+        if not hasattr(self, "_has_lost"):
+            if self._compute_intermediate_reward:
+                self._has_lost = self._game_progression.failed
+            else:
+                self._has_lost = '*** You lost! ***' in self.feedback
+
+        return self._has_lost
 
     @property
     def game_ended(self) -> bool:

textworld/generator/game.py

@@ -564,7 +564,7 @@ def __init__(self, quest: Quest) -> None:
         Args:
             quest: The quest to keep track of its completion.
         """
-        self._quest = quest
+        self.quest = quest
         self._completed = False
         self._failed = False
         self._unfinishable = False
@@ -617,12 +617,12 @@ def update(self, action: Optional[Action] = None, state: Optional[State] = None)
 
         if state is not None:
             # Check if quest is completed.
-            if self._quest.win_action is not None:
-                self._completed = state.is_applicable(self._quest.win_action)
+            if self.quest.win_action is not None:
+                self._completed = state.is_applicable(self.quest.win_action)
 
             # Check if quest has failed.
-            if self._quest.fail_action is not None:
-                self._failed = state.is_applicable(self._quest.fail_action)
+            if self.quest.fail_action is not None:
+                self._failed = state.is_applicable(self.quest.fail_action)
 
             # Try compressing the winning policy given the new game state.
             if self.compress_winning_policy(state):
@@ -696,17 +696,33 @@ def __init__(self, game: Game, track_quests: bool = True) -> None:
     @property
     def done(self) -> bool:
         """ Whether all quests are completed or at least one has failed or is unfinishable. """
+        return self.completed or self.failed
+
+    @property
+    def completed(self) -> bool:
+        """ Whether all quests are completed. """
         if not self.tracking_quests:
-            return False  # There is nothing to be "done".
+            return False  # There is nothing to be "completed".
 
-        all_completed = True
-        for quest_progression in self.quest_progressions:
-            if quest_progression.failed or quest_progression.unfinishable:
-                return True
+        return all(qp.completed for qp in self.quest_progressions)
 
-            all_completed &= quest_progression.completed
+    @property
+    def failed(self) -> bool:
+        """ Whether at least one quest has failed or is unfinishable. """
+        if not self.tracking_quests:
+            return False  # There is nothing to be "failed".
+
+        return any((qp.failed or qp.unfinishable) for qp in self.quest_progressions)
 
-        return all_completed
+    @property
+    def score(self) -> int:
+        """ Sum of the reward of all completed quests. """
+        return sum(qp.quest.reward for qp in self.quest_progressions if qp.completed)
+
+    @property
+    def max_score(self) -> int:
+        """ Sum of the reward of all quests. """
+        return sum(quest.reward for quest in self.game.quests)
 
     @property
     def tracking_quests(self) -> bool: