def test_going_through_door(): P = Variable("P", "P") room = Variable("room", "r") kitchen = Variable("kitchen", "r") state = State(KnowledgeBase.default().logic) state.add_facts([ Proposition("at", [P, room]), Proposition("north_of", [kitchen, room]), Proposition("free", [kitchen, room]), Proposition("free", [room, kitchen]), Proposition("south_of", [room, kitchen]) ]) options = ChainingOptions() options.backward = True options.max_depth = 3 options.max_length = 3 options.subquests = True options.create_variables = True options.rules_per_depth = [ [KnowledgeBase.default().rules["take/c"], KnowledgeBase.default().rules["take/s"]], KnowledgeBase.default().rules.get_matching("go.*"), [KnowledgeBase.default().rules["open/d"]], ] chains = list(get_chains(state, options)) assert len(chains) == 18
def test_going_through_door(): P = Variable("P", "P") room = Variable("room", "r") kitchen = Variable("kitchen", "r") state = State() state.add_facts([ Proposition("at", [P, room]), Proposition("north_of", [kitchen, room]), Proposition("free", [kitchen, room]), Proposition("free", [room, kitchen]), Proposition("south_of", [room, kitchen]) ]) # Sample quests. chains = [] rules_per_depth = { 0: [data.get_rules()["take/c"], data.get_rules()["take/s"]], 1: data.get_rules().get_matching("go.*"), 2: [data.get_rules()["open/d"]] } tree_of_possible = chaining.get_chains(state, max_depth=3, allow_partial_match=True, exceptions=[], rules_per_depth=rules_per_depth, backward=True) chains = list(tree_of_possible.traverse_preorder(subquests=True)) # chaining.print_chains(chains) # 1. take/c(P, room, c_0, o_0, I) # 2. take/c(P, room, c_0, o_0, I) -> go/north(P, r_0, room) # 3. take/c(P, room, c_0, o_0, I) -> go/north(P, r_0, room) -> open/d(P, r_0, d_0, room) # 4. take/c(P, room, c_0, o_0, I) -> go/south(P, kitchen, room) # 5. take/c(P, room, c_0, o_0, I) -> go/south(P, kitchen, room) -> open/d(P, kitchen, d_0, room) # 6. take/c(P, room, c_0, o_0, I) -> go/east(P, r_0, room) # 7. take/c(P, room, c_0, o_0, I) -> go/east(P, r_0, room) -> open/d(P, r_0, d_0, room) # 8. take/c(P, room, c_0, o_0, I) -> go/west(P, r_0, room) # 9. take/c(P, room, c_0, o_0, I) -> go/west(P, r_0, room) -> open/d(P, r_0, d_0, room) # 10. take/s(P, room, s_0, o_0, I) # 11. take/s(P, room, s_0, o_0, I) -> go/north(P, r_0, room) # 12. take/s(P, room, s_0, o_0, I) -> go/north(P, r_0, room) -> open/d(P, r_0, d_0, room) # 13. take/s(P, room, s_0, o_0, I) -> go/south(P, kitchen, room) # 14. take/s(P, room, s_0, o_0, I) -> go/south(P, kitchen, room) -> open/d(P, kitchen, d_0, room) # 15. take/s(P, room, s_0, o_0, I) -> go/east(P, r_0, room) # 16. take/s(P, room, s_0, o_0, I) -> go/east(P, r_0, room) -> open/d(P, r_0, d_0, room) # 17. take/s(P, room, s_0, o_0, I) -> go/west(P, r_0, room) # 18. take/s(P, room, s_0, o_0, I) -> go/west(P, r_0, room) -> open/d(P, r_0, d_0, room) assert len(chains) == 18
class World: def __init__(self, kb: Optional[KnowledgeBase] = None) -> None: self.kb = kb or KnowledgeBase.default() self._state = State(self.kb.logic) self._entities = OrderedDict() self._rooms = [] self._objects = [] self._update() self._player_room = None @classmethod def from_facts(cls, facts: List[Proposition], kb: Optional[KnowledgeBase] = None) -> "World": world = cls(kb=kb) world.add_facts(facts) return world @classmethod def deserialize(cls, serialized_facts: List, kb: Optional[KnowledgeBase] = None) -> "World": return cls.from_facts( [Proposition.deserialize(f) for f in serialized_facts], kb=kb) def serialize(self) -> List: return [f.serialize() for f in self.facts] @classmethod def from_map(cls, map: networkx.Graph, kb: Optional[KnowledgeBase] = None) -> "World": """ Args: map: Graph defining the structure of the world. """ world = cls(kb=kb) names = [ d.get("name", "r_{}".format(i)) for i, (n, d) in enumerate(map.nodes.items()) ] rooms = OrderedDict( (n, Variable(names[i], "r")) for i, n in enumerate(map.nodes())) world.add_facts(graph2state(map, rooms)) return world @property def player_room(self) -> WorldRoom: return self._player_room @property def rooms(self) -> List[WorldRoom]: return self._rooms @property def objects(self) -> List[WorldObject]: return self._objects @property def entities(self) -> ValuesView[WorldEntity]: return self._entities.values() @property def state(self) -> State: return self._state @state.setter def state(self, state: State) -> None: self._state = State(self.kb.logic) self.add_facts(state.facts) @property def facts(self) -> List[Proposition]: # Sort the facts for deterministic world generation return sorted(self._state.facts) def add_fact(self, fact: Proposition) -> None: self.add_facts([fact]) def add_facts(self, facts: List[Proposition]) -> None: self._state.add_facts(facts) self._update() # Update the internal representation of the world. def _get_entity(self, var: Variable) -> WorldEntity: if var.name not in self._entities: self._entities[var.name] = WorldEntity.create(var) return self._entities[var.name] def _get_room(self, var: Variable) -> WorldRoom: entity = self._get_entity(var) assert isinstance(entity, WorldRoom) return entity def _get_object(self, var: Variable) -> WorldObject: entity = self._get_entity(var) assert isinstance(entity, WorldObject) return entity def _update(self) -> None: """ Update the internal representation of the world. This method will create new entities based on facts. It should be called whenever backing facts are changed. """ self._entities = OrderedDict() # Clear entities. self.player = self._get_entity(Variable("P")) self.inventory = self._get_entity(Variable("I")) self._player_room = None self._process_rooms() self._process_objects() self._rooms = [ entity for entity in self._entities.values() if isinstance(entity, WorldRoom) ] self._objects = [ entity for entity in self._entities.values() if isinstance(entity, WorldObject) ] self._entities_per_type = defaultdict(list) for entity in self._entities.values(): self._entities_per_type[entity.type].append(entity) def _process_rooms(self) -> None: for fact in self.facts: if not self.kb.types.is_descendant_of(fact.arguments[0].type, 'r'): continue # Skip non room facts. room = self._get_room(fact.arguments[0]) room.add_related_fact(fact) if fact.name.endswith("_of"): # Handle room positioning facts. exit = reverse_direction(fact.name.split("_of")[0]) dest = self._get_room(fact.arguments[1]) dest.add_related_fact(fact) assert exit not in room.exits room.exits[exit] = dest # Handle door link facts. for fact in self.facts: if fact.name != "link": continue src = self._get_room(fact.arguments[0]) door = self._get_object(fact.arguments[1]) dest = self._get_room(fact.arguments[2]) door.add_related_fact(fact) src.content.append(door) exit_found = False for exit, room in src.exits.items(): if dest == room: src.doors[exit] = door exit_found = True break if not exit_found: # Need to position both rooms w.r.t. each other. src_free_exits = [ exit for exit in DIRECTIONS if exit not in src.exits ] for exit in src_free_exits: r_exit = reverse_direction(exit) if r_exit not in dest.exits: src.exits[exit] = dest dest.exits[r_exit] = src src.doors[exit] = door exit_found = True break # Relax the Cartesian grid constraint. if not exit_found: # Need to position both rooms w.r.t. each other. src_free_exits = [ exit for exit in DIRECTIONS if exit not in src.exits ] dest_free_exits = [ exit for exit in DIRECTIONS if exit not in dest.exits ] if len(src_free_exits) > 0 and len(dest_free_exits) > 0: exit = src_free_exits[0] r_exit = dest_free_exits[0] src.exits[exit] = dest dest.exits[r_exit] = src src.doors[exit] = door exit_found = True if not exit_found: # If there is still no exit found. raise NoFreeExitError("Cannot connect {} and {}.".format( src, dest)) def _process_objects(self) -> None: for fact in self.facts: if self.kb.types.is_descendant_of(fact.arguments[0].type, 'r'): continue # Skip room facts. obj = self._get_entity(fact.arguments[0]) obj.add_related_fact(fact) if fact.name == "match": other_obj = self._get_entity(fact.arguments[1]) obj.matching_entity_id = fact.arguments[1].name other_obj.matching_entity_id = fact.arguments[0].name if fact.name in ["in", "on", "at"]: holder = self._get_entity(fact.arguments[1]) holder.content.append(obj) if fact.arguments[0].type == "P": self._player_room = holder def get_facts_in_scope(self) -> List[Proposition]: facts = [] facts += [ fact for exit in self.player_room.exits.values() for fact in exit.related_facts ] facts += [ fact for door in self.player_room.doors.values() for fact in door.related_facts ] facts += [ fact for obj in self.get_visible_objects_in(self.player_room) for fact in obj.related_facts ] facts += [ fact for obj in self.get_objects_in_inventory() for fact in obj.related_facts ] return uniquify(facts) def get_visible_objects_in(self, obj: WorldObject) -> List[WorldObject]: if "locked" in obj.properties or "closed" in obj.properties: return [] objects = list(obj.content) for obj in obj.content: objects += self.get_visible_objects_in(obj) return objects def get_all_objects_in(self, obj: WorldObject) -> List[WorldObject]: objects = list(obj.content) for obj in obj.content: objects += self.get_all_objects_in(obj) return objects def get_objects_in_inventory(self) -> List[WorldObject]: return self.inventory.content def get_entities_per_type(self, type: str) -> List[WorldEntity]: """ Get all entities of a certain type. """ return self._entities_per_type.get(type, []) def find_object_by_id(self, id: str) -> Optional[WorldObject]: return self._entities.get(id) def find_room_by_id(self, id: str) -> Optional[WorldRoom]: return self._entities.get(id) def set_player_room( self, start_room: Union[None, WorldRoom, str] = None) -> Proposition: if start_room is None: if len(self.rooms) == 0: start_room = WorldRoom("r_0", "r") else: start_room = self.rooms[0] elif start_room in self._entities: start_room = self._entities[start_room] elif isinstance(start_room, Variable) and start_room.name in self._entities: start_room = self._entities[start_room.name] else: raise ValueError("Unknown room: {}".format(start_room)) fact = Proposition("at", [self.player, start_room]) self.add_fact(fact) return fact def populate_room( self, nb_objects: int, room: Variable, rng: Optional[RandomState] = None, object_types_probs: Optional[Dict[str, float]] = None ) -> List[Proposition]: rng = g_rng.next() if rng is None else rng state = [] types_counts = self.kb.types.count(self.state) inventory = Variable("I", "I") objects_holder = [inventory, room] locked_or_closed_objects = [] lockable_objects = [] for s in self.facts: # Look for containers and supporters to put stuff in/on them. if s.name == "at" and s.arguments[0].type in [ "c", "s" ] and s.arguments[1].name == room.name: objects_holder.append(s.arguments[0]) # Look for containers and doors without a matching key. if s.name == "at" and s.arguments[0].type in [ "c", "d" ] and s.arguments[1].name == room.name: obj_propositions = [ p.name for p in self.facts if s.arguments[0].name in p.names ] if "match" not in obj_propositions and s.arguments[ 0] not in lockable_objects: lockable_objects.append(s.arguments[0]) if "locked" in obj_propositions or "closed" in obj_propositions: locked_or_closed_objects.append(s.arguments[0]) object_id = 0 while object_id < nb_objects: if len(locked_or_closed_objects) > 0: # Prioritize adding key if there are locked or closed things in the room. obj_type = "k" else: obj_type = self.kb.types.sample(parent_type='t', rng=rng, exceptions=["d", "r"], include_parent=False, probs=object_types_probs) if self.kb.types.is_descendant_of(obj_type, "o"): obj_name = get_new(obj_type, types_counts) obj = Variable(obj_name, obj_type) allowed_objects_holder = list(objects_holder) if obj_type == "k": if len(locked_or_closed_objects) > 0: # Look for a *locked* container or a door. rng.shuffle(locked_or_closed_objects) locked_or_closed_obj = locked_or_closed_objects.pop() state.append( Proposition("match", [obj, locked_or_closed_obj])) lockable_objects.remove(locked_or_closed_obj) # Do not place the key in its own matching container. if locked_or_closed_obj in allowed_objects_holder: allowed_objects_holder.remove(locked_or_closed_obj) elif len(lockable_objects) > 0: # Look for a container or a door. rng.shuffle(lockable_objects) lockable_obj = lockable_objects.pop() state.append(Proposition("match", [obj, lockable_obj])) else: continue # Unuseful key is not allowed. elif obj_type == "f": # HACK: manually add the edible property to food items. state.append(Proposition("edible", [obj])) # Place the object somewhere. obj_holder = rng.choice(allowed_objects_holder) if self.kb.types.is_descendant_of(obj_holder.type, "s"): state.append(Proposition("on", [obj, obj_holder])) elif self.kb.types.is_descendant_of(obj_holder.type, "c"): state.append(Proposition("in", [obj, obj_holder])) elif self.kb.types.is_descendant_of(obj_holder.type, "I"): state.append(Proposition("in", [obj, obj_holder])) elif self.kb.types.is_descendant_of(obj_holder.type, "r"): state.append(Proposition("at", [obj, obj_holder])) else: raise ValueError( "Unknown type for object holder: {}".format( obj_holder)) elif self.kb.types.is_descendant_of(obj_type, "s"): supporter_name = get_new(obj_type, types_counts) supporter = Variable(supporter_name, obj_type) state.append(Proposition("at", [supporter, room])) objects_holder.append(supporter) elif self.kb.types.is_descendant_of(obj_type, "c"): container_name = get_new(obj_type, types_counts) container = Variable(container_name, obj_type) state.append(Proposition("at", [container, room])) objects_holder.append(container) container_state = rng.choice(["open", "closed", "locked"]) state.append(Proposition(container_state, [container])) lockable_objects.append(container) if container_state in ["locked", "closed"]: locked_or_closed_objects.append(container) else: raise ValueError("Unknown object type: {}".format(obj_type)) object_id += 1 self.add_facts(state) return state def populate( self, nb_objects: int, rng: Optional[RandomState] = None, object_types_probs: Optional[Dict[str, float]] = None ) -> List[Proposition]: rng = g_rng.next() if rng is None else rng room_names = [room.id for room in self.rooms] nb_objects_per_room = {room_name: 0 for room_name in room_names} indices = np.arange(len(room_names)) for _ in range(nb_objects): idx = rng.choice(indices) nb_objects_per_room[room_names[idx]] += 1 state = [] for room in self.rooms: state += self.populate_room(nb_objects_per_room[room.id], room, rng, object_types_probs) return state def populate_room_with( self, objects: WorldObject, room: WorldRoom, rng: Optional[RandomState] = None) -> List[Proposition]: rng = g_rng.next() if rng is None else rng state = [] objects_holder = [room] locked_or_closed_objects = [] lockable_objects = [] for s in self.facts: # Look for containers and supporters to put stuff in/on them. if s.name == "at" and s.arguments[0].type in [ "c", "s" ] and s.arguments[1].name == room.name: objects_holder.append(s.arguments[0]) # Look for containers and doors without a matching key. if s.name == "at" and s.arguments[0].type in [ "c", "d" ] and s.arguments[1].name == room.name: obj_propositions = [ p.name for p in self.facts if s.arguments[0].name in p.names ] if "match" not in obj_propositions and s.arguments[ 0] not in lockable_objects: lockable_objects.append(s.arguments[0]) if "locked" in obj_propositions or "closed" in obj_propositions: locked_or_closed_objects.append(s.arguments[0]) remaining_objects_id = list(range(len(objects))) rng.shuffle(remaining_objects_id) for idx in remaining_objects_id: obj = objects[idx] obj_type = obj.type if self.kb.types.is_descendant_of(obj_type, "o"): allowed_objects_holder = list(objects_holder) # Place the object somewhere. obj_holder = rng.choice(allowed_objects_holder) if self.kb.types.is_descendant_of(obj_holder.type, "s"): state.append(Proposition("on", [obj, obj_holder])) elif self.kb.types.is_descendant_of(obj_holder.type, "c"): state.append(Proposition("in", [obj, obj_holder])) elif self.kb.types.is_descendant_of(obj_holder.type, "r"): state.append(Proposition("at", [obj, obj_holder])) else: raise ValueError( "Unknown type for object holder: {}".format( obj_holder)) elif self.kb.types.is_descendant_of(obj_type, "s"): supporter = obj state.append(Proposition("at", [supporter, room])) objects_holder.append(supporter) elif self.kb.types.is_descendant_of(obj_type, "c"): container = obj state.append(Proposition("at", [container, room])) objects_holder.append(container) container_state = rng.choice(["open", "closed", "locked"]) state.append(Proposition(container_state, [container])) lockable_objects.append(container) if container_state in ["locked", "closed"]: locked_or_closed_objects.append(container) else: raise ValueError("Unknown object type: {}".format(obj_type)) self.add_facts(state) return state def populate_with(self, objects: List[WorldObject], rng: Optional[RandomState] = None) -> List[Proposition]: rng = g_rng.next() if rng is None else rng room_names = [room.id for room in self.rooms] nb_objects_per_room = {room_name: 0 for room_name in room_names} indices = np.arange(len(room_names)) for _ in range(len(objects)): idx = rng.choice(indices) nb_objects_per_room[room_names[idx]] += 1 state = [] for room in self.rooms: state += self.populate_room_with( objects[:nb_objects_per_room[room.id]], room, rng) objects = objects[nb_objects_per_room[room.id]:] self.add_facts(state) return state def __eq__(self, other: Any) -> bool: return (isinstance(other, World) and self.state == other.state) def __hash__(self) -> int: return hash(frozenset(self.facts))