def change_grammar(self, grammar: Grammar) -> None:
""" Changes the grammar used and regenerate all text. """
self.grammar = grammar
_gen_commands = gen_commands_from_actions
if self.grammar:
from textworld.generator.inform7 import Inform7Game
from textworld.generator.text_generation import generate_text_from_grammar
inform7 = Inform7Game(self)
_gen_commands = inform7.gen_commands_from_actions
generate_text_from_grammar(self, self.grammar)
for quest in self.quests:
# TODO: should have a generic way of generating text commands from actions
# instead of relying on inform7 convention.
for event in quest.win_events:
event.commands = _gen_commands(event.actions)
if quest.win_events:
quest.commands = quest.win_events[0].commands
# Check if we can derive a global winning policy from the quests.
if self.grammar:
from textworld.generator.text_generation import describe_event
policy = GameProgression(self).winning_policy
if policy:
mapping = {k: info.name for k, info in self._infos.items()}
commands = [a.format_command(mapping) for a in policy]
self.metadata["walkthrough"] = commands
self.objective = describe_event(Event(policy), self,
self.grammar)
def test_game_with_infinite_max_score(self):
M = textworld.GameMaker()
museum = M.new_room("Museum")
statue = M.new(type="o", name="golden statue")
pedestal = M.new(type="s", name="pedestal")
pedestal.add(statue)
museum.add(pedestal)
M.set_player(museum)
M.quests = [
Quest(win_events=[
Event(conditions=[M.new_fact('in', statue, M.inventory)]),
],
reward=10,
optional=True,
repeatable=True),
Quest(win_events=[
Event(conditions=[M.new_fact('at', statue, museum)]),
],
reward=0)
]
M.set_walkthrough(
["take golden statue from pedestal", "look", "drop statue"])
game = M.build()
assert game.max_score == np.inf
inform7 = Inform7Game(game)
game_progress = GameProgression(game)
assert len(game_progress.quest_progressions) == len(game.quests)
# Following the actions associated to the last quest actually corresponds
# to solving the whole game.
for action in game_progress.winning_policy:
assert not game_progress.done
game_progress.update(action)
assert game_progress.done
assert not game_progress.quest_progressions[
0].completed # Repeatable quests can never be completed.
assert game_progress.quest_progressions[
1].completed # Mandatory quest.
# Solve the game while completing the optional quests.
game_progress = GameProgression(game)
for command in [
"take golden statue from pedestal", "look", "look",
"drop golden statue"
]:
_apply_command(command, game_progress, inform7)
progressions = game_progress.quest_progressions
assert not progressions[0].done # Repeatable quests can never be done.
assert progressions[
0].nb_completions == 3 # They could have been completed a number of times, though.
assert progressions[1].done
assert game_progress.score == 30
def init(self,
output: str,
game: Game,
state_tracking: bool = False,
compute_intermediate_reward: bool = False):
"""
Initialize the game state and set tracking parameters.
The tracking parameters, state_tracking and compute_intermediate_reward,
are computationally expensive, so are disabled by default.
:param output: Introduction text displayed when a game starts.
:param game: The glulx game to run
:param state_tracking: Whether to use state tracking
:param compute_intermediate_reward: Whether to compute the intermediate reward
"""
output = _strip_input_prompt_symbol(output)
_, output = _detect_i7_events_debug_tags(output)
self._extra_infos, output = _detect_extra_infos(output)
super().init(output)
self._game = game
self._game_progression = GameProgression(game,
track_quests=state_tracking)
self._inform7 = Inform7Game(game)
self._state_tracking = state_tracking
self._compute_intermediate_reward = compute_intermediate_reward and len(
game.quests) > 0
self._objective = game.objective
self._score = 0
self._max_score = self._game.max_score
def _find_action(command: str, actions: Iterable[Action], inform7: Inform7Game) -> None:
""" Apply a text command to a game_progression object. """
commands = inform7.gen_commands_from_actions(actions)
for action, cmd in zip(actions, commands):
if command == cmd:
return action
raise ValueError("No action found matching command: {}.".format(command))
def _apply_command(command: str, game_progression: GameProgression, inform7: Inform7Game) -> None:
""" Apply a text command to a game_progression object.
"""
valid_commands = inform7.gen_commands_from_actions(game_progression.valid_actions)
for action, cmd in zip(game_progression.valid_actions, valid_commands):
if command == cmd:
game_progression.update(action)
return
raise ValueError("Not a valid command: {}. Expected: {}".format(command, valid_commands))
def main_quest(self):
if self._main_quest is None:
from textworld.generator.inform7 import Inform7Game
from textworld.generator.text_generation import assign_description_to_quest
inform7 = Inform7Game(self)
self._main_quest = Quest(actions=GameProgression(self).winning_policy)
self._main_quest.desc = assign_description_to_quest(self._main_quest, self, self.grammar)
self._main_quest.commands = inform7.gen_commands_from_actions(self._main_quest.actions)
return self._main_quest
def load(self, gamefile: str) -> None:
self._gamefile = os.path.splitext(gamefile)[0] + ".json"
if not os.path.isfile(self._gamefile):
raise MissingGameInfosError(self)
try:
self._game = self._wrapped_env._game
except AttributeError:
self._game = Game.load(self._gamefile)
self._inform7 = Inform7Game(self._game)
self._wrapped_env.load(gamefile)
def change_grammar(self, grammar: Grammar) -> None:
""" Changes the grammar used and regenerate all text. """
self.grammar = grammar
if self.grammar is None:
return
from textworld.generator.inform7 import Inform7Game
from textworld.generator.text_generation import generate_text_from_grammar
inform7 = Inform7Game(self)
generate_text_from_grammar(self, self.grammar)
for quest in self.quests:
# TODO: should have a generic way of generating text commands from actions
# instead of relying on inform7 convention.
quest.commands = inform7.gen_commands_from_actions(quest.actions)
def main_quest(self):
if self._main_quest is None:
from textworld.generator.inform7 import Inform7Game
from textworld.generator.text_generation import assign_description_to_quest
inform7 = Inform7Game(self)
# TODO: defining the main quest using the actions might not be precise enough
# since it only looks at the final action's postconditions.
# Check if we can derive a winning policy from the quests.
policy = GameProgression(self).winning_policy
if policy:
win_event = Event(actions=GameProgression(self).winning_policy)
self._main_quest = Quest(win_events=[win_event])
self._main_quest.desc = assign_description_to_quest(
self._main_quest, self, self.grammar)
self._main_quest.commands = inform7.gen_commands_from_actions(
win_event.actions)
return self._main_quest
def main():
args = parse_args()
# Load game for which to sample quests for.
game = Game.load(args.game.replace(".ulx", ".json"))
options = ChainingOptions()
options.backward = False
options.max_depth = args.quest_length
options.max_breadth = args.quest_breadth
options.rules_per_depth = {}
options.create_variables = False
options.rng = np.random.RandomState(args.seed)
# Sample quests.
chains = []
for i in range(args.nb_quests):
chain = sample_quest(game.world.state, options)
chains.append(chain)
inform7 = Inform7Game(game)
print_chains(chains, inform7)
# Convert chains to networkx graph/tree
filename_world = pjoin(args.output, "sample_world.png")
filename_tree = pjoin(args.output, "sample_tree.svg")
filename_graph = pjoin(args.output, "sample_graph.svg")
G, labels = build_tree_from_chains(chains, inform7)
if len(G) > 0:
image = visualize(game)
image.save(filename_world)
tree = nx.bfs_tree(G, "root")
save_graph_to_svg(tree, labels, filename_tree)
save_graph_to_svg(G, labels, filename_graph)
else:
try:
os.remove(filename_world)
os.remove(filename_tree)
os.remove(filename_graph)
except:
pass
def setUpClass(cls):
M = GameMaker()
# The goal
commands = ["go east", "insert carrot into chest"]
# Create a 'bedroom' room.
R1 = M.new_room("bedroom")
R2 = M.new_room("kitchen")
M.set_player(R1)
path = M.connect(R1.east, R2.west)
path.door = M.new(type='d', name='wooden door')
path.door.add_property("open")
carrot = M.new(type='f', name='carrot')
M.inventory.add(carrot)
# Add a closed chest in R2.
chest = M.new(type='c', name='chest')
chest.add_property("open")
R2.add(chest)
cls.eventA = M.new_event_using_commands(commands)
cls.eventB = Event(conditions={
M.new_fact("at", carrot, R1),
M.new_fact("closed", path.door)
})
cls.eventC = Event(conditions={M.new_fact("eaten", carrot)})
cls.eventD = Event(conditions={
M.new_fact("closed", chest),
M.new_fact("closed", path.door)
})
cls.quest = Quest(win_events=[cls.eventA, cls.eventB],
fail_events=[cls.eventC, cls.eventD],
reward=2)
M.quests = [cls.quest]
cls.game = M.build()
cls.inform7 = Inform7Game(cls.game)
def change_grammar(self, grammar: Grammar) -> None:
""" Changes the grammar used and regenerate all text. """
from textworld.generator.inform7 import Inform7Game
from textworld.generator.text_generation import generate_text_from_grammar
self.grammar = grammar
_gen_commands = gen_commands_from_actions
if self.grammar:
inform7 = Inform7Game(self)
_gen_commands = inform7.gen_commands_from_actions
generate_text_from_grammar(self, self.grammar)
for quest in self.quests:
# TODO: should have a generic way of generating text commands from actions
# instead of relying on inform7 convention.
for event in quest.win_events:
event.commands = _gen_commands(event.actions)
quest.commands = quest.win_events[0].commands
if self.main_quest:
win_event = self.main_quest.win_events[0]
self.main_quest.commands = _gen_commands(win_event.actions)
def test_game_with_optional_and_repeatable_quests(self):
M = textworld.GameMaker()
museum = M.new_room("Museum")
weak_statue = M.new(type="o", name="ivory statue")
normal_statue = M.new(type="o", name="stone statue")
strong_statue = M.new(type="o", name="granite statue")
museum.add(weak_statue)
museum.add(normal_statue)
museum.add(strong_statue)
M.set_player(museum)
M.quests = [
Quest(win_events=[
Event(conditions=[M.new_fact('in', weak_statue, M.inventory)]),
],
reward=-10,
optional=True,
repeatable=True),
Quest(win_events=[
Event(
conditions=[M.new_fact('in', normal_statue, M.inventory)]),
],
reward=3,
optional=True),
Quest(
win_events=[
Event(conditions=[
M.new_fact('in', strong_statue, M.inventory)
]),
],
reward=5,
)
]
M.set_walkthrough(
["take ivory", "take stone", "drop ivory", "take granite"])
game = M.build()
inform7 = Inform7Game(game)
game_progress = GameProgression(game)
assert len(game_progress.quest_progressions) == len(game.quests)
# Following the actions associated to the last quest actually corresponds
# to solving the whole game.
for action in game_progress.winning_policy:
assert not game_progress.done
game_progress.update(action)
assert game_progress.done
assert not game_progress.quest_progressions[
0].completed # Optional, negative quest.
assert not game_progress.quest_progressions[
1].completed # Optional, positive quest.
assert game_progress.quest_progressions[
2].completed # Mandatory quest.
# Solve the game while completing the optional quests.
game_progress = GameProgression(game)
for command in [
"take ivory statue", "look", "take stone statue",
"drop ivory statue", "take granite statue"
]:
_apply_command(command, game_progress, inform7)
progressions = game_progress.quest_progressions
assert not progressions[0].done # Repeatable quests can never be done.
assert progressions[
0].nb_completions == 3 # They could have been completed a number of times, though.
assert progressions[
1].done # The nonrepeatable-optional quest can be done.
assert progressions[2].done
assert game.max_score == 8
assert game_progress.score == -22
def test_game_with_multiple_quests(self):
M = GameMaker()
# The subgoals (needs to be executed in order).
commands = [
[
"open wooden door", "go west", "take carrot", "go east",
"drop carrot"
],
# Now, the player is back in the kitchen and the wooden door is open.
["go west", "take lettuce", "go east", "drop lettuce"],
# Now, the player is back in the kitchen, there are a carrot and a lettuce on the floor.
[
"take lettuce", "take carrot", "insert carrot into chest",
"insert lettuce into chest", "close chest"
]
]
# Create a 'bedroom' room.
R1 = M.new_room("bedroom")
R2 = M.new_room("kitchen")
M.set_player(R2)
path = M.connect(R1.east, R2.west)
path.door = M.new(type='d', name='wooden door')
path.door.add_property("closed")
carrot = M.new(type='f', name='carrot')
lettuce = M.new(type='f', name='lettuce')
R1.add(carrot, lettuce)
# Add a closed chest in R2.
chest = M.new(type='c', name='chest')
chest.add_property("open")
R2.add(chest)
quest1 = M.new_quest_using_commands(commands[0])
quest1.desc = "Fetch the carrot and drop it on the kitchen's ground."
quest2 = M.new_quest_using_commands(commands[0] + commands[1])
quest2.desc = "Fetch the lettuce and drop it on the kitchen's ground."
quest3 = M.new_quest_using_commands(commands[0] + commands[1] +
commands[2])
winning_facts = [
M.new_fact("in", lettuce, chest),
M.new_fact("in", carrot, chest),
M.new_fact("closed", chest)
]
quest3.win_events[0].set_conditions(winning_facts)
quest3.desc = "Put the lettuce and the carrot into the chest before closing it."
M.quests = [quest1, quest2, quest3]
assert len(M.quests) == len(commands)
game = M.build()
inform7 = Inform7Game(game)
game_progress = GameProgression(game)
assert len(game_progress.quest_progressions) == len(game.quests)
# Following the actions associated to the last quest actually corresponds
# to solving the whole game.
for action in game_progress.winning_policy:
assert not game_progress.done
game_progress.update(action)
assert game_progress.done
assert all(quest_progression.done
for quest_progression in game_progress.quest_progressions)
# Try solving the game by greedily taking the first action from the current winning policy.
game_progress = GameProgression(game)
while not game_progress.done:
action = game_progress.winning_policy[0]
game_progress.update(action)
# print(action.name, [c.name for c in game_progress.winning_policy])
# Try solving the second quest (i.e. bringing back the lettuce) first.
game_progress = GameProgression(game)
for command in [
"open wooden door", "go west", "take lettuce", "go east",
"drop lettuce"
]:
_apply_command(command, game_progress, inform7)
assert not game_progress.quest_progressions[0].done
assert game_progress.quest_progressions[1].done
for command in ["go west", "take carrot", "go east", "drop carrot"]:
_apply_command(command, game_progress, inform7)
assert game_progress.quest_progressions[0].done
assert game_progress.quest_progressions[1].done
for command in [
"take lettuce", "take carrot", "insert carrot into chest",
"insert lettuce into chest", "close chest"
]:
_apply_command(command, game_progress, inform7)
assert game_progress.done
# Game is done whenever a quest has failed or is unfinishable.
game_progress = GameProgression(game)
for command in [
"open wooden door", "go west", "take carrot", "eat carrot"
]:
assert not game_progress.done
_apply_command(command, game_progress, inform7)
assert game_progress.done
def test_cycle_in_winning_policy(self):
M = GameMaker()
# Create a map.
# r0
# |
# r1 -- r2
# | |
# r3 -- r4
R0 = M.new_room("r0")
R1 = M.new_room("r1")
R2 = M.new_room("r2")
R3 = M.new_room("r3")
R4 = M.new_room("r4")
M.set_player(R1)
M.connect(R0.south, R1.north),
M.connect(R1.east, R2.west),
M.connect(R3.east, R4.west)
M.connect(R1.south, R3.north)
M.connect(R2.south, R4.north)
carrot = M.new(type='f', name='carrot')
R0.add(carrot)
apple = M.new(type='f', name='apple')
R2.add(apple)
commands = ["go north", "take carrot"]
M.set_quest_from_commands(commands)
game = M.build()
inform7 = Inform7Game(game)
game_progression = GameProgression(game)
_apply_command("go south", game_progression, inform7)
expected_commands = ["go north"] + commands
winning_commands = inform7.gen_commands_from_actions(
game_progression.winning_policy)
assert winning_commands == expected_commands, "{} != {}".format(
winning_commands, expected_commands)
_apply_command("go east", game_progression, inform7)
_apply_command("go north", game_progression, inform7)
expected_commands = ["go south", "go west", "go north"] + commands
winning_commands = inform7.gen_commands_from_actions(
game_progression.winning_policy)
assert winning_commands == expected_commands, "{} != {}".format(
winning_commands, expected_commands)
_apply_command("go west", game_progression, inform7) # Found shortcut
expected_commands = commands
winning_commands = inform7.gen_commands_from_actions(
game_progression.winning_policy)
assert winning_commands == expected_commands, "{} != {}".format(
winning_commands, expected_commands)
# Quest where player's has to pick up the carrot first.
commands = [
"go east", "take apple", "go west", "go north", "drop apple"
]
M.set_quest_from_commands(commands)
game = M.build()
game_progression = GameProgression(game)
_apply_command("go south", game_progression, inform7)
expected_commands = ["go north"] + commands
winning_commands = inform7.gen_commands_from_actions(
game_progression.winning_policy)
assert winning_commands == expected_commands, "{} != {}".format(
winning_commands, expected_commands)
_apply_command("go east", game_progression, inform7)
expected_commands = ["go west", "go north"] + commands
winning_commands = inform7.gen_commands_from_actions(
game_progression.winning_policy)
assert winning_commands == expected_commands, "{} != {}".format(
winning_commands, expected_commands)
_apply_command("go north", game_progression, inform7) # Found shortcut
expected_commands = commands[1:]
winning_commands = inform7.gen_commands_from_actions(
game_progression.winning_policy)
assert winning_commands == expected_commands, "{} != {}".format(
winning_commands, expected_commands)
def load(self, path: str) -> None:
self._gamefile = path
self._game = textworld.Game.load(self._gamefile)
self._game_progression = None
self._inform7 = Inform7Game(self._game)