def handle_destroy(self, speaker, d) -> Tuple[Any, Optional[str], Any]:
"""This function reads the dictionary, resolves the missing details using memory
and perception and handles a 'destroy' command by either pushing a dialogue object
or pushing a Destroy task to the task stack.
Args:
speaker: speaker_id or name.
d: the complete action dictionary
"""
default_ref_d = {"filters": {"location": SPEAKERLOOK}}
ref_d = d.get("reference_object", default_ref_d)
objs = self.subinterpret["reference_objects"](
self, speaker, ref_d, extra_tags=["_destructible"])
if len(objs) == 0:
raise ErrorWithResponse(
"I don't understand what you want me to destroy.")
# don't kill mobs
if all(isinstance(obj, MobNode) for obj in objs):
raise ErrorWithResponse("I don't kill animals, sorry!")
if all(isinstance(obj, PlayerNode) for obj in objs):
raise ErrorWithResponse("I don't kill players, sorry!")
objs = [obj for obj in objs if not isinstance(obj, MobNode)]
tasks = []
for obj in objs:
if hasattr(obj, "blocks"):
schematic = list(obj.blocks.items())
task_data = {"schematic": schematic, "action_dict": d}
tasks.append(self.task_objects["destroy"](self.agent,
task_data))
logging.info("Added {} Destroy tasks to stack".format(len(tasks)))
return maybe_task_list_to_control_block(tasks, self.agent), None, None
def move(self, vect): if self.task: self.task.close() self.task = None if not vect: return self.task = self.move_task(vect) tasks.append(self.task)
def handle_modify(self, speaker, d) -> Tuple[Any, Optional[str], Any]:
"""This function reads the dictionary, resolves the missing details using memory
and handles a 'modify' command by either replying back or pushing
appropriate tasks to the task stack.
Args:
speaker: speaker_id or name.
d: the complete action dictionary
"""
default_ref_d = {"filters": {"location": SPEAKERLOOK}}
ref_d = d.get("reference_object", default_ref_d)
# only modify blockobjects...
objs = self.subinterpret["reference_objects"](
self,
speaker,
ref_d,
extra_tags=["_physical_object", "VOXEL_OBJECT"])
if len(objs) == 0:
raise ErrorWithResponse(
"I don't understand what you want me to modify.")
m_d = d.get("modify_dict")
if not m_d:
raise ErrorWithResponse(
"I think you want me to modify an object but am not sure what to do"
)
tasks = []
for obj in objs:
if m_d["modify_type"] == "THINNER" or m_d[
"modify_type"] == "THICKER":
destroy_task_data, build_task_data = handle_thicken(
self, speaker, m_d, obj)
elif m_d["modify_type"] == "REPLACE":
destroy_task_data, build_task_data = handle_replace(
self, speaker, m_d, obj)
elif m_d["modify_type"] == "SCALE":
destroy_task_data, build_task_data = handle_scale(
self, speaker, m_d, obj)
elif m_d["modify_type"] == "RIGIDMOTION":
destroy_task_data, build_task_data = handle_rigidmotion(
self, speaker, m_d, obj)
elif m_d["modify_type"] == "FILL" or m_d["modify_type"] == "HOLLOW":
destroy_task_data, build_task_data = handle_fill(
self, speaker, m_d, obj)
else:
raise ErrorWithResponse(
"I think you want me to modify an object but am not sure what to do (parse error)"
)
if build_task_data:
tasks.append(self.task_objects["build"](self.agent,
build_task_data))
if destroy_task_data:
tasks.append(self.task_objects["build"](self.agent,
destroy_task_data))
return maybe_task_list_to_control_block(tasks, self.agent), None, None
def create_tasks(angles, n_levels, n_nodes):
tasks = []
for a in angles:
for r in range(n_levels + 1):
print 'Creating task: r%da%dn%d' % (r, a, n_nodes)
taskName = 'r%da%dn%d' % (r, a, n_nodes)
# Add task to queue and append return value to tasks
tasks.append((taskName, (a, a, 1, n_nodes, r)))
return list(set(tasks))
def pan(vect):
global task
if task:
task.close()
task = None
if not vect:
return
task = pan_task(vect)
tasks.append(task)
def on_mouse_press(x, y, button, modifiers): if ui.on_mouse_press(x, y, button, modifiers): return True real_x, real_y = view.screen2world(x, y) ship.translate(real_x, real_y) # background flash tasks.append(fx.flash_task(0.5)) # sparks test sparks = fx.Sparks((real_x, real_y, 0.0)) scene.models.append(sparks) tasks.append(sparks.update_task())
def get_training_tasks(args):
tasks = []
for task_name in args.training_tasks:
if 'SemEval18' == task_name:
for emotion in SemEval18SingleEmotionTask.EMOTIONS:
tasks.append(
SemEval18SingleEmotionTask(emotion,
cls_dim=args.mlp_dims[-1]))
else:
tasks.append(get_task_by_name(args, task_name))
return tasks
def parse_tasks(config_file, dry_run=False):
tasks = []
f = open(config_file, 'r')
config = configparser.ConfigParser()
config.read_file(f)
f.close()
for s in config.sections():
actions = config.get(s, "actions")
for a in actions.split(","):
a = a.strip(" []{}")
config_items = dict(config.items(s))
period = parse_period(config_items["period"])
drives_filepaths = []
t = actions_classes[a](s, period, drives_filepaths, config_items,
dry_run)
tasks.append(t)
return tasks
def handle_spawn(self, speaker, d) -> Tuple[Any, Optional[str], Any]:
"""This function reads the dictionary, resolves the missing details using memory
and handles a 'spawn' command by either replying back or
pushing a Spawn task to the task stack.
Args:
speaker: speaker_id or name.
d: the complete action dictionary
"""
# FIXME! use filters appropriately, don't search by hand
spawn_triples = d.get("reference_object",
{}).get("filters", {}).get("triples", [])
if not spawn_triples:
raise ErrorWithResponse(
"I don't understand what you want me to spawn.")
names = [
t.get("obj_text") for t in spawn_triples
if t.get("pred_text", "") == "has_name"
]
if not any(names):
raise ErrorWithResponse(
"I don't understand what you want me to spawn.")
# if multiple possible has_name triples, just pick the first:
object_name = names[0]
schematic = self.memory.get_mob_schematic_by_name(object_name)
if not schematic:
raise ErrorWithResponse("I don't know how to spawn: %r." %
(object_name))
object_idm = list(schematic.blocks.values())[0]
location_d = d.get("location", SPEAKERLOOK)
mems = self.subinterpret["reference_locations"](self, speaker,
location_d)
steps, reldir = interpret_relative_direction(self, location_d)
pos, _ = self.subinterpret["specify_locations"](self, speaker, mems,
steps, reldir)
repeat_times = get_repeat_num(d)
tasks = []
for i in range(repeat_times):
task_data = {
"object_idm": object_idm,
"pos": pos,
"action_dict": d
}
tasks.append(self.task_objects["spawn"](self.agent, task_data))
return maybe_task_list_to_control_block(tasks, self.agent), None, None
def translate(self, x, y): if self.task: self.task.close() if self.pos != (x, y): self.task = self.translate_task((x, y)) tasks.append(self.task)
def handle_fill(self, speaker, d) -> Tuple[Any, Optional[str], Any]:
"""This function reads the dictionary, resolves the missing details using memory
and perception and handles a 'fill' command by either pushing a dialogue object
or pushing a Fill task to the task stack.
Args:
speaker: speaker_id or name.
d: the complete action dictionary
"""
tasks = []
r = d.get("reference_object")
if not r.get("filters"):
r["filters"] = {"location", SPEAKERLOOK}
# Get the reference location
location_d = r["filters"].get("location", SPEAKERLOOK)
mems = self.subinterpret["reference_locations"](self, speaker,
location_d)
steps, reldir = interpret_relative_direction(self, location_d)
location, _ = self.subinterpret["specify_locations"](self, speaker,
mems, steps,
reldir)
# Get nearby holes
holes: List[Hole] = heuristic_perception.get_all_nearby_holes(
self.agent, location)
candidates: List[Tuple[XYZ, Hole]] = [
(to_block_pos(np.mean(hole[0], axis=0)), hole) for hole in holes
]
# Choose the best ones to fill
repeat = get_repeat_num(d)
holes = filter_by_sublocation(self,
speaker,
candidates,
r,
limit=repeat,
loose=True)
if holes is None:
self.dialogue_stack.append_new(
Say, "I don't understand what holes you want me to fill.")
return None, None, None
tasks = []
for hole in holes:
_, hole_info = hole
poss, hole_idm = hole_info
schematic, tags = interpret_fill_schematic(self, speaker,
d.get("schematic", {}),
poss, hole_idm)
origin = np.min([xyz for (xyz, bid) in schematic], axis=0)
task_data = {
"blocks_list": schematic,
"force": True,
"origin": origin,
"verbose": False,
"embed": True,
"fill_message": True,
"schematic_tags": tags,
}
tasks.append(self.task_objects["build"](self.agent, task_data))
if len(holes) > 1:
self.dialogue_stack.append_new(Say, "Ok. I'll fill up the holes.")
else:
self.dialogue_stack.append_new(Say, "Ok. I'll fill that hole up.")
return maybe_task_list_to_control_block(tasks, self.agent), None, None
def handle_build(self, speaker, d) -> Tuple[Any, Optional[str], Any]:
"""This function reads the dictionary, resolves the missing details using memory
and perception and handles a 'build' command by either pushing a dialogue object
or pushing a Build task to the task stack.
Args:
speaker: speaker_id or name.
d: the complete action dictionary
"""
# Get the segment to build
if "reference_object" in d:
# handle copy
repeat = get_repeat_num(d)
objs = self.subinterpret["reference_objects"](
self,
speaker,
d["reference_object"],
limit=repeat,
extra_tags=["VOXEL_OBJECT"],
loose_speakerlook=True,
)
if len(objs) == 0:
raise ErrorWithResponse(
"I don't understand what you want me to build")
tagss = [[(p, v)
for (_, p, v) in self.memory.get_triples(subj=obj.memid)]
for obj in objs]
interprets = [[list(obj.blocks.items()), obj.memid, tags]
for (obj, tags) in zip(objs, tagss)]
else: # a schematic
if d.get("repeat") is not None:
repeat_dict = d
else:
repeat_dict = None
interprets = interpret_schematic(self,
speaker,
d.get("schematic", {}),
repeat_dict=repeat_dict)
# Get the locations to build
location_d = d.get("location", SPEAKERLOOK)
mems = self.subinterpret["reference_locations"](self, speaker,
location_d)
steps, reldir = interpret_relative_direction(self, location_d)
origin, offsets = self.subinterpret["specify_locations"](
self,
speaker,
mems,
steps,
reldir,
repeat_dir=get_repeat_dir(location_d),
objects=interprets,
enable_geoscorer=True,
)
interprets_with_offsets = [(blocks, mem, tags, off)
for (blocks, mem,
tags), off in zip(interprets, offsets)]
tasks_data = []
for schematic, schematic_memid, tags, offset in interprets_with_offsets:
og = np.array(origin) + offset
task_data = {
"blocks_list": schematic,
"origin": og,
"schematic_memid": schematic_memid,
"schematic_tags": tags,
"action_dict": d,
}
tasks_data.append(task_data)
tasks = []
for td in tasks_data:
t = self.task_objects["build"](self.agent, td)
tasks.append(t)
logging.info("Adding {} Build tasks to stack".format(len(tasks)))
return maybe_task_list_to_control_block(tasks, self.agent), None, None
