def get_holes(interpreter, speaker, location, limit=1, all_proximity=10) -> List[Tuple[XYZ, Hole]]: holes: List[Hole] = perception.get_all_nearby_holes( interpreter.agent, location) candidates: List[Tuple[XYZ, Hole]] = [ (to_block_pos(np.mean(hole[0], axis=0)), hole) for hole in holes ] if len(candidates) > 0: # NB(demiguo): by default, we fill the hole the player is looking at player = interpreter.memory.get_player_struct_by_name(speaker) centroid_hole = object_looked_at(interpreter.agent, candidates, player, limit=limit) if centroid_hole is None or len(centroid_hole) == 0: # NB(demiguo): if there's no hole in front of the player, we will fill the nearest hole speaker_pos = interpreter.memory.get_player_struct_by_name( speaker).pos speaker_pos = to_block_pos(pos_to_np(speaker_pos)) if limit == "ALL": return list( filter( lambda c: euclid_dist(c[0], speaker_pos) <= all_proximity, candidates)) else: candidates.sort(key=lambda c: euclid_dist(c[0], speaker_pos)) return candidates[:limit] else: return centroid_hole else: return []
def come_to_player(agent): """Go to where the player is.""" op = agent.get_other_players() if len(op) == 0: return p = random.choice(agent.get_other_players()) agent.memory.task_stack_push(tasks.Move(agent, {"target": pos_to_np(p.pos), "approx": 3}))
def step(self): """Extract bot's current location.""" self.finished = True # Get the agent's current location agent_pos = pos_to_np(self.agent.get_player().pos) agent_coordinates = " , ".join([str(pos) for pos in agent_pos]) answer_options = [ "I am here at location : %r" % (agent_coordinates), "I am standing at : %r" % (agent_coordinates), "I am at : %r" % (agent_coordinates), ] return random.choice(answer_options), None
def perceive(self, force=False): # FIXME (low pri) remove these in code, get from sql self.agent.pos = to_block_pos(pos_to_np(self.agent.get_player().pos)) if self.agent.count % self.perceive_freq == 0 or force: for mob in self.agent.get_mobs(): if euclid_dist(self.agent.pos, pos_to_np( mob.pos)) < self.memory.perception_range: self.memory.set_mob_position(mob) for item_stack in self.agent.get_item_stacks(): if (euclid_dist(self.agent.pos, pos_to_np(item_stack.pos)) < self.memory.perception_range): self.memory.set_item_stack_position(item_stack) # note: no "force"; these run on every perceive call. assumed to be fast self.update_self_memory() self.update_other_players(self.agent.get_other_players()) # use safe_get_changed_blocks to deal with pointing for (xyz, idm) in self.agent.safe_get_changed_blocks(): self.on_block_changed(xyz, idm)
def perceive(self, force=False): # FIXME (low pri) remove these in code, get from sql self.agent.pos = to_block_pos(pos_to_np(self.agent.get_player().pos)) # note: no "force"; these run on every perceive call. assumed to be fast for mob in self.agent.get_mobs(): self.memory.set_mob_position(mob) self.update_other_players(self.agent.get_other_players()) # use safe_get_changed_blocks to deal with pointing for (xyz, idm) in self.agent.safe_get_changed_blocks(): self.on_block_changed(xyz, idm)
def step(self): self.pos = to_block_pos(pos_to_np(self.get_player().pos)) # Update memory with current world state # Removed get_objects call due to very slow updates on non-flatworlds with TimingWarn(2): self.memory.update(self) # Process incoming chats self.dialogue_step() # Step topmost task on stack self.task_step()
def _is_placed_block_interesting(self, xyz: XYZ, bid: int) -> Tuple[bool, bool]: """Return two values: - bool: is the placed block interesting? - bool: is it interesting because it was placed by a player? """ if xyz in self.pending_agent_placed_blocks: self.pending_agent_placed_blocks.remove(xyz) return True, True for player in self.other_players.values(): if util.euclid_dist(util.pos_to_np(player.pos), xyz) < 5 and player.mainHand.id == bid: return True, True if bid not in BORING_BLOCKS: return True, False return False, False
def compute_location_heuristic(interpreter, speaker, d, mems): # handle relative direction reldir = d.get("relative_direction") loc = mems[0].get_pos() if reldir is not None: if reldir == "BETWEEN": loc = (np.add(mems[0].get_pos(), mems[1].get_pos())) / 2 loc = (loc[0], loc[1], loc[2]) elif reldir == "INSIDE": ref_obj_dict = d.get("reference_object", SPEAKERLOOK["reference_object"]) special = ref_obj_dict.get("special_reference") if not special: for i in range(len(mems)): mem = mems[i] locs = heuristic_perception.find_inside(mem) if len(locs) > 0: break if len(locs) == 0: raise ErrorWithResponse("I don't know how to go inside there") else: interpreter.memory.update_recent_entities([mem]) loc = locs[0] else: raise ErrorWithResponse("I don't know how to go inside there") elif reldir == "AWAY": apos = pos_to_np(interpreter.agent.get_player().pos) dir_vec = (apos - loc) / np.linalg.norm(apos - loc) num_steps = word_to_num(d.get("steps", "5")) loc = num_steps * np.array(dir_vec) + to_block_center(loc) elif reldir == "NEAR": pass else: # LEFT, RIGHT, etc... reldir_vec = rotation.DIRECTIONS[reldir] look = ( interpreter.agent.perception_modules["low_level"] .get_player_struct_by_name(speaker) .look ) # this should be an inverse transform so we set inverted=True dir_vec = rotation.transform(reldir_vec, look.yaw, 0, inverted=True) num_steps = word_to_num(d.get("steps", "5")) loc = num_steps * np.array(dir_vec) + to_block_center(loc) # if steps without relative direction elif "steps" in d: num_steps = word_to_num(d.get("steps", "5")) loc = to_block_center(loc) + [0, 0, num_steps] return post_process_loc(loc, interpreter)
def step(self): self.pos = to_block_pos(pos_to_np(self.get_player().pos)) # remove old point targets self.point_targets = [pt for pt in self.point_targets if time.time() - pt[1] < 6] # Update memory with current world state # Removed perceive call due to very slow updates on non-flatworlds with TimingWarn(2): self.memory.update(self) # Process incoming chats self.dialogue_step() # Step topmost task on stack self.task_step()
def _is_placed_block_interesting(self, xyz: XYZ, bid: int) -> Tuple[bool, bool, bool]: """Return three values: - bool: is the placed block interesting? - bool: is it interesting because it was placed by a player? - bool: is it interesting because it was placed by the agent? """ interesting = False player_placed = False agent_placed = False # TODO record *which* player placed it if xyz in self.pending_agent_placed_blocks: self.pending_agent_placed_blocks.remove(xyz) interesting = True agent_placed = True for player in self.other_players.values(): if util.euclid_dist(util.pos_to_np(player.pos), xyz) < 5 and player.mainHand.id == bid: interesting = True player_placed = True if bid not in BORING_BLOCKS: interesting = True return interesting, player_placed, agent_placed
def get_speaker_pos(self) -> XYZ: return tuple( pos_to_np(self.memory.get_player_struct_by_name(self.speaker).pos))
def interpret_location(interpreter, speaker, d, ignore_reldir=False) -> XYZ: """Location dict -> coordinates Side effect: adds mems to agent_memory.recent_entities if a reference object is interpreted; and loc to memory """ location_type = d.get("location_type", "SPEAKER_LOOK") if location_type == "REFERENCE_OBJECT": mems = interpret_reference_object(interpreter, speaker, d["reference_object"]) if len(mems) == 0: raise ErrorWithResponse("I don't know what you're referring to") assert len(mems) == 1, mems interpreter.memory.update_recent_entities(mems) mem = mems[0] loc = mem.get_pos() elif location_type == "SPEAKER_LOOK": player = interpreter.memory.get_player_struct_by_name(speaker) loc = capped_line_of_sight(interpreter.agent, player) elif location_type == "SPEAKER_POS": loc = pos_to_np( interpreter.memory.get_player_struct_by_name(speaker).pos) elif location_type == "AGENT_POS": loc = pos_to_np(interpreter.agent.get_player().pos) elif location_type == "COORDINATES": loc = cast( XYZ, tuple( int(float(w)) for w in re.findall("[-0-9.]+", d["coordinates"]))) if len(loc) != 3: logging.error("Bad coordinates: {}".format(d["coordinates"])) raise ErrorWithResponse( "I don't understand what location you're referring to") else: raise ValueError( "Can't handle Location type: {}".format(location_type)) # handle relative direction reldir = d.get("relative_direction") if reldir is not None and not ignore_reldir: if reldir == "INSIDE": if location_type == "REFERENCE_OBJECT": locs = perception.find_inside(mem) if len(locs) == 0: raise ErrorWithResponse( "I don't know how to go inside there") else: loc = locs[0] elif reldir == "AWAY": apos = pos_to_np(interpreter.agent.get_player().pos) dir_vec = (apos - loc) / np.linalg.norm(apos - loc) num_steps = word_to_num(d.get("steps", "5")) loc = num_steps * np.array(dir_vec) + to_block_center(loc) elif reldir == "NEAR": pass else: # LEFT, RIGHT, etc... reldir_vec = rotation.DIRECTIONS[reldir] look = interpreter.memory.get_player_struct_by_name(speaker).look # this should be an inverse transform so we set inverted=True dir_vec = rotation.transform(reldir_vec, look.yaw, 0, inverted=True) num_steps = word_to_num(d.get("steps", "5")) loc = num_steps * np.array(dir_vec) + to_block_center(loc) # if steps without relative direction elif "steps" in d: num_steps = word_to_num(d.get("steps", "5")) loc = to_block_center(loc) + [0, 0, num_steps] return to_block_pos(loc)
def get_players(interpreter, *tags) -> List[Tuple[XYZ, PlayerNode]]: """Return a list of (xyz, memory) tuples, filtered by tags""" players = interpreter.memory.get_players_tagged(*tags) return [(to_block_pos(pos_to_np(player.pos)), player) for player in players]