| """This module implements the classes needed to represent the fictional world of the game. |
| |
| The world class includes references to the several components (Items, Locations, Character), |
| and methods to update according to the detected changes by a language model. |
| """ |
|
|
| import re |
| from typing import Type |
|
|
|
|
| class Component: |
| """A class to represent a component of the world. |
| |
| The components considered in the PAYADOR approach are Items, Locations and Characters. |
| """ |
| def __init__ (self, name:str, descriptions: 'list[str]'): |
|
|
| self.name = name |
| """the name of the component""" |
|
|
| self.descriptions = descriptions |
| """a set of natural language descriptions for the component""" |
| |
| class Puzzle (Component): |
| """A class to represent a Puzzle""" |
|
|
| def __init__(self, name:str, descriptions: 'list[str]', problem: str, answer: str): |
| |
| super().__init__(name, descriptions) |
| """inherited from Component""" |
|
|
| self.problem = problem |
| """the main problem to be solved""" |
|
|
| self.answer = answer |
| """a possible answer to the riddle or puzzle""" |
|
|
| class Item (Component): |
| """A class to represent an Item.""" |
| def __init__ (self, name:str, descriptions: 'list[str]', gettable: bool = True): |
|
|
| super().__init__(name, descriptions) |
| """inherited from Component""" |
|
|
| self.gettable = gettable |
| """indicates if the Item can be taken by the player""" |
|
|
| class Location (Component): |
| """A class to represent a Location in the world.""" |
| def __init__ (self, name:str, descriptions: 'list[str]', items: 'list[Item]' = None, connecting_locations: 'list[Location]' = None): |
|
|
| super().__init__(name, descriptions) |
| """inherited from Component""" |
|
|
| self.items = items or [] |
| """a list of the items available in that location""" |
|
|
| self.connecting_locations = connecting_locations or [] |
| """a list of the reachable locations from itself.""" |
|
|
| self.blocked_locations = {} |
| """a dictionary with the name of a location as key and <location,obstacle,symmetric> as value. |
| A blocked passage between self and a location means that it |
| will be reachable from [self] after overcoming the [obstacle]. |
| The symmetric variable is a boolean that indicates if, when unblocked, |
| [self] will also be reachable from [location]. |
| """ |
|
|
| def block_passage(self, location: 'Location', obstacle, symmetric: bool = True): |
| """Block a passage between self and location using an obstacle.""" |
| if location in self.connecting_locations: |
| if location.name not in self.blocked_locations: |
| self.blocked_locations[location.name] = (location, obstacle, symmetric) |
| self.connecting_locations = [x for x in self.connecting_locations if x is not location] |
| else: |
| raise Exception(f"Error: A blocked passage to {location.name} already exists") |
| else: |
| raise Exception(f"Error: Two non-conected locations cannot be blocked") |
|
|
| def unblock_passage(self, location: 'Location'): |
| """Unblock a passage between self and location by adding it to the connecting locations of self. |
| |
| In case that the block was symmetric, self will be added to the connecting locations of location. |
| """ |
| if self.blocked_locations[location.name]: |
| self.connecting_locations += [location] |
| if self.blocked_locations[location.name][2] and self not in location.connecting_locations: |
| location.connecting_locations += [self] |
| del self.blocked_locations[location.name] |
| else: |
| raise Exception("Error: That is not a blocked passage") |
|
|
| class Character (Component): |
| """A class to represent a character.""" |
| def __init__ (self, name:str, descriptions: 'list[str]', location:Location, inventory: 'list[Item]' = None): |
|
|
| super().__init__(name, descriptions) |
| """inherited from Component""" |
|
|
| self.inventory = inventory or [] |
| """a set of Items the carachter has""" |
|
|
| self.location = location |
| """the location of the character""" |
|
|
| self.visited_locations = {self.location.name: []} |
| """a dictionary that contains the successive descriptions of the visited places""" |
|
|
| def move(self, new_location: Location): |
| """Move the character to a new location.""" |
| if new_location in self.location.connecting_locations: |
| self.location = new_location |
| if self.location.name not in self.visited_locations: |
| self.visited_locations[self.location.name] = [] |
| else: |
| raise Exception(f"Error: {new_location.name} is not reachable") |
|
|
| def save_item(self,item: Item, item_location_or_owner): |
| """Add an item to the character inventory.""" |
| if item.gettable: |
| if item not in self.inventory: |
| self.inventory += [item] |
| if item_location_or_owner.__class__.__name__ == 'Character': |
| item_location_or_owner.inventory = [i for i in item_location_or_owner.inventory if i is not item] |
| elif item_location_or_owner.__class__.__name__ == 'Location': |
| item_location_or_owner.items = [i for i in item_location_or_owner.items if i is not item] |
| else: |
| raise Exception(f"Error: {item.name} is already in your inventory") |
| else: |
| raise Exception(f"Error: {item.name} cannot be taken") |
|
|
| def drop_item (self, item: Item): |
| """Leave an item in the current location.""" |
| self.inventory = [i for i in self.inventory if i is not item] |
| self.location.items += [item] |
|
|
| def give_item (self, character: 'Character', item: Item): |
| """Give an item to another character.""" |
| try: |
| character.save_item(item, self) |
| except Exception as e: |
| print(e) |
|
|
|
|
| class World: |
| """A class to represent the fictional world, with references to every component.""" |
| def __init__ (self, player: Character) -> None: |
|
|
| self.items = {} |
| """a dictionary of all the Items in the world, with their names as values""" |
|
|
| self.characters = {} |
| """a dictionary of all the Characters in the world, with their names as values""" |
|
|
| self.locations = {} |
| """a dictionary of all the Locations in the world, with their names as values""" |
|
|
| self.player = player |
| """a character for the player""" |
|
|
| self.objective = None |
| """the current objective for the player in this world""" |
|
|
| def set_objective (self, first_component: Type[Component], second_component: Type[Component]): |
| |
| first_component_class = first_component.__class__.__name__ |
| second_component_class = second_component.__class__.__name__ |
| |
| if first_component_class == "Character" and second_component_class == "Character": |
| self.objective = (first_component, second_component) |
| elif (first_component_class == "Character" and second_component_class in ["Location", "Item"]) or (second_component_class == "Character" and first_component_class in ["Location", "Item"]): |
| self.objective = (first_component, second_component) |
| elif (first_component_class == "Item" and second_component_class == "Location") or (second_component_class == "Item" and first_component_class == "Location"): |
| self.objective = (first_component, second_component) |
| else: |
| raise Exception(f"Error: Cannot set objective with classes {first_component_class} and {second_component_class}") |
|
|
| def check_objective(self) -> bool: |
|
|
| done = False |
| first_component_class = self.objective[0].__class__.__name__ |
| second_component_class = self.objective[1].__class__.__name__ |
|
|
| if first_component_class == "Character" and second_component_class == "Character": |
| if self.objective[0].location == self.objective[1].location: done = True |
| elif first_component_class == "Character" and second_component_class == "Location": |
| if self.objective[0].location == self.objective[1]: done = True |
| elif first_component_class == "Character" and second_component_class == "Item": |
| if self.objective[1] in self.objective[0].inventory: done = True |
| elif first_component_class == "Item" and second_component_class == "Location": |
| if self.objective[0] in self.objective[1].items: done = True |
|
|
| return done |
|
|
| def add_location (self,location: Location) -> None: |
| """Add a location to the world.""" |
| if location.name in self.locations: |
| raise Exception(f"Error: Already exists a location called '{location.name}'") |
| else: |
| self.locations[location.name] = location |
|
|
| def add_item (self, item: Item) -> None: |
| """Add an item to the world.""" |
| if item.name in self.items: |
| raise Exception(f"Error: Already exists an item called '{item.name}'") |
| else: |
| self.items[item.name] = item |
|
|
| def add_character (self, character: Character) -> None: |
| """Add a character to the world.""" |
| if character.name in self.characters: |
| raise Exception(f"Error: Already exists a character called '{character.name}'") |
| else: |
| self.characters[character.name] = character |
|
|
| def add_locations (self,locations: 'list[Location]') -> None: |
| """"Add a set of locations to the world.""" |
| for location in locations: |
| self.add_location(location) |
|
|
| def add_items (self, items: 'list[Item]') -> None: |
| """Add a set of items to the world.""" |
| for item in items: |
| self.add_item(item) |
|
|
| def add_characters (self, characters: 'list[Character]') -> None: |
| """Add a set of characters to the world.""" |
| for character in characters: |
| self.add_character(character) |
|
|
| def render_world(self, *, language:str = 'en', detail_components:bool = True) -> str: |
| """Return the fictional world as a natural language description, using simple sentences. |
| |
| The components described are only those the player can see in the current location. |
| If detail_components is False, then the descriptions for each component are not included. |
| """ |
| rendered_world = '' |
|
|
| if language == 'es': |
| rendered_world = self.__render_world_spanish(detail_components = detail_components) |
| else: |
| rendered_world = self.__render_world_english(detail_components = detail_components) |
|
|
| return rendered_world |
| |
| def __render_world_spanish(self, *, detail_components:bool = True) -> str: |
| """Return the fictional world as a natural language description, using simple sentences in Spanish. |
| |
| The components described are only those the player can see in the current location. |
| If detail_components is False, then the descriptions for each component are not included. |
| """ |
| player_location = self.player.location |
| reachable_locations = [f"<{p.name}>" for p in player_location.connecting_locations] |
| blocked_passages = [f"<{p}> bloqueado por <{player_location.blocked_locations[p][1].name}>" for p in player_location.blocked_locations.keys()] |
| characters_in_the_scene = [character for character in self.characters.values() if character.location is player_location] |
|
|
| |
| world_description = f'El jugador está en <{player_location.name}>\n' |
| |
| if reachable_locations: |
| world_description += f'Desde <{player_location.name}> el jugador puede ir a: {(", ").join(reachable_locations)}\n' |
| else: |
| world_description += f'Desde <{player_location.name}> el jugador puede ir a: None\n' |
|
|
| if blocked_passages: |
| world_description += f'Desde <{player_location.name}> hay pasajes bloqueados hacia: {(", ").join(blocked_passages)}\n' |
| else: |
| world_description += f'Desde <{player_location.name}> hay pasajes bloqueados hacia: None\n' |
|
|
| if self.player.inventory: |
| world_description += f'El jugador tiene los siguientes objetos en su inventario: {(", ").join([f"<{i.name}>" for i in self.player.inventory])}\n' |
| else: |
| world_description += f'El jugador tiene los siguientes objetos en su inventario: None\n' |
|
|
| if player_location.items: |
| world_description += f'El jugador puede ver los siguientes objetos: {(", ").join([f"<{i.name}>" for i in player_location.items])}\n' |
| else: |
| world_description += f'El jugador puede ver los siguientes objetos: None\n' |
| |
| if characters_in_the_scene: |
| world_description += f'El jugador puede ver a los siguientes personajes: {(", ").join([f"<{c.name}>" for c in characters_in_the_scene])}' |
| else: |
| world_description += f'El jugador puede ver a los siguientes personajes: None' |
|
|
| details = "" |
| if detail_components: |
| items_in_the_scene = player_location.items + self.player.inventory + [blocked_values[1] for blocked_values in player_location.blocked_locations.values() if isinstance(blocked_values[1], Item)] |
| puzzles_in_the_scene = [blocked_values[1] for blocked_values in player_location.blocked_locations.values() if isinstance(blocked_values[1], Puzzle)] |
|
|
| details += "\nAquí hay una descripción de cada componente.\n" |
| details += f"<{player_location.name}>: Este es el lugar en el que está el jugador. {('. ').join(player_location.descriptions)}.\n" |
| details += "Personajes:\n" |
| details += f"- <Jugador>: El jugador está actuando como <{self.player.name}>. {('. ').join(self.player.descriptions)}.\n" |
| if len(characters_in_the_scene)>0: |
| for character in characters_in_the_scene: |
| details += f"- <{character.name}>: {('. ').join(character.descriptions)}." |
| if len(character.inventory)>0: |
| details += f"Este personaje tiene los siguientes objetos en su inventario: {(', ').join([f'<{i.name}>' for i in character.inventory])}\n" |
| items_in_the_scene+= character.inventory |
| else: |
| details += "\n" |
| if len(items_in_the_scene)>0: |
| details+="Objetos:\n" |
| for item in items_in_the_scene: |
| details += f"- <{item.name}>: {('. ').join(item.descriptions)}\n" |
| if len(puzzles_in_the_scene)>0: |
| details+="Puzzles:\n" |
| for puzzle in puzzles_in_the_scene: |
| details+= f'- <{puzzle.name}>: {(". ").join(puzzle.descriptions)}. El acertijo a resolver es: "{puzzle.problem}". La respuesta esperada, que NO PUEDES decirle al jugador (JAMÁS) es: "{puzzle.answer}".\n' |
|
|
| return world_description + '\n' + details |
|
|
| def __render_world_english(self, *, detail_components:bool = True) -> str: |
| """Return the fictional world as a natural language description, using simple sentences in English. |
| |
| The components described are only those the player can see in the current location. |
| If detail_components is False, then the descriptions for each component are not included. |
| """ |
| player_location = self.player.location |
| reachable_locations = [f"<{p.name}>" for p in player_location.connecting_locations] |
| blocked_passages = [f"<{p}> blocked by <{player_location.blocked_locations[p][1].name}>" for p in player_location.blocked_locations.keys()] |
| characters_in_the_scene = [character for character in self.characters.values() if character.location is player_location] |
|
|
| |
| world_description = f'The player is in <{player_location.name}>\n' |
| |
| if reachable_locations: |
| world_description += f'From <{player_location.name}> the player can access: {(", ").join(reachable_locations)}\n' |
| else: |
| world_description += f'From <{player_location.name}> the player can access: None\n' |
|
|
| if blocked_passages: |
| world_description += f'From <{player_location.name}> there are blocked passages to: {(", ").join(blocked_passages)}\n' |
| else: |
| world_description += f'From <{player_location.name}> there are blocked passages to: None\n' |
|
|
| if self.player.inventory: |
| world_description += f'The player has the following objects in the inventory: {(", ").join([f"<{i.name}>" for i in self.player.inventory])}\n' |
| else: |
| world_description += f'The player has the following objects in the inventory: None\n' |
|
|
| if player_location.items: |
| world_description += f'The player can see the following objects: {(", ").join([f"<{i.name}>" for i in player_location.items])}\n' |
| else: |
| world_description += f'The player can see the following objects: None\n' |
| |
| if characters_in_the_scene: |
| world_description += f'The player can see the following characters: {(", ").join([f"<{c.name}>" for c in characters_in_the_scene])}' |
| else: |
| world_description += f'The player can see the following characters: None' |
|
|
| details = "" |
| if detail_components: |
| items_in_the_scene = player_location.items + self.player.inventory + [blocked_values[1] for blocked_values in player_location.blocked_locations.values() if isinstance(blocked_values[1], Item)] |
| puzzles_in_the_scene = [blocked_values[1] for blocked_values in player_location.blocked_locations.values() if isinstance(blocked_values[1], Puzzle)] |
|
|
| details += "\nHere is a description of each component.\n" |
| details += f"<{player_location.name}>: This is the player's location. {('. ').join(player_location.descriptions)}.\n" |
| details += "Characters:\n" |
| details += f"- <Player>: The player is acting as <{self.player.name}>. {('. ').join(self.player.descriptions)}.\n" |
| if len(characters_in_the_scene)>0: |
| for character in characters_in_the_scene: |
| details += f"- <{character.name}>: {('. ').join(character.descriptions)}." |
| if len(character.inventory)>0: |
| details += f" This character has the following items: {(', ').join([f'<{i.name}>' for i in character.inventory])}\n" |
| items_in_the_scene+= character.inventory |
| else: |
| details += "\n" |
| if len(items_in_the_scene)>0: |
| details+="Objects:\n" |
| for item in items_in_the_scene: |
| details += f"- <{item.name}>: {('. ').join(item.descriptions)}\n" |
| if len(puzzles_in_the_scene)>0: |
| details+="Puzzles:\n" |
| for puzzle in puzzles_in_the_scene: |
| details+= f'- <{puzzle.name}>: {(". ").join(puzzle.descriptions)}. The riddle to solve is: "{puzzle.problem}". The expected answer, that you CANNOT tell the player (EVER) is: "{puzzle.answer}".\n' |
|
|
| return world_description + '\n' + details |
|
|
| def update (self, updates: str) -> None: |
| """Does the changes in the world according to the output of the language model. |
| |
| The possible changes considered are: |
| - an object was moved |
| - a location is now reachable |
| - the position of the player changed. |
| """ |
| self.parse_moved_objects(updates) |
| self.parse_blocked_passages(updates) |
| self.parse_location_change(updates) |
|
|
| def parse_moved_objects (self, updates: str) -> None: |
| """Parse the output of the language model to update the position of objects. |
| |
| There are three cases: |
| - the player has a new item |
| - the player gave an item to other character |
| - the player dropped an item. |
| """ |
| parsed_objects = re.findall(r".*Moved object:\s*(.+)",updates) |
| if 'None' not in parsed_objects: |
| parsed_objects_split = re.findall(r"<[^<>]*?>.*?<[^<>]*?>",parsed_objects[0]) |
| for parsed_object in parsed_objects_split: |
| pair = re.findall(r"<([^<>]*?)>.*?<([^<>]*?)>",parsed_object) |
| try: |
| world_item = self.items[pair[0][0]] |
| |
| if pair[0][1] in ['Inventory', 'Inventario', 'Player', 'Jugador', self.player.name]: |
| item_location = [character for character in list(self.characters.values()) if world_item in character.inventory] |
| item_location += [location for location in list(self.locations.values()) if world_item in location.items] |
| self.player.save_item(world_item, item_location[0]) |
|
|
| elif pair[0][1] in self.characters: |
| self.player.give_item(self.characters[pair[0][1]], world_item) |
| |
| else: |
| self.player.drop_item(world_item) |
| except Exception as e: |
| print(e) |
|
|
| def parse_blocked_passages (self, updates: str) -> None: |
| """Parse the output of the language model to update the reachable locations.""" |
| parsed_blocked_passages = re.findall(r".*Blocked passages now available:\s*(.+)",updates) |
| if 'None' not in parsed_blocked_passages: |
| parsed_blocked_passages_split = re.findall(r"<([^<>]*?)>",parsed_blocked_passages[0]) |
| for parsed_passage in parsed_blocked_passages_split: |
| try: |
| self.locations[self.player.location.name].unblock_passage(self.locations[parsed_passage]) |
| except Exception as e: |
| print (e) |
|
|
| def parse_location_change (self, updates: str) -> None: |
| """Parse the output of the language model to update the position of the player.""" |
| parsed_location_change = re.findall(r".*Your location changed: (.+)",updates) |
| if "None" not in parsed_location_change: |
| parsed_location_change_split = re.findall(r"<([^<>]*?)>",parsed_location_change[0]) |
| try: |
| self.player.move(self.locations[parsed_location_change_split[0]]) |
| except Exception as e: |
| print(e) |
|
|
|
|
