def add_effect(tmp_effect, results, durative=False): time = None if durative: time = tmp_effect.time parameters = [] if isinstance(tmp_effect, UniversalEffect): parameters = tmp_effect.parameters tmp_effect = tmp_effect.effects[0] if durative: condition = [ conditions.Truth(), conditions.Truth(), conditions.Truth() ] else: condition = conditions.Truth() if isinstance(tmp_effect, ConditionalEffect): condition = tmp_effect.condition tmp_effect = tmp_effect.effects[0] if isinstance(tmp_effect, ConjunctiveEffect): assert len(tmp_effect.effects) == 1 tmp_effect = tmp_effect.effects[0] assert not isinstance(tmp_effect, TmpEffect) if time == "start": results[0].append(Effect(parameters, condition, tmp_effect)) elif time == "end": results[1].append(Effect(parameters, condition, tmp_effect)) else: assert not durative results.append(Effect(parameters, condition, tmp_effect))
def normalize(self): effects = [] for eff in self.effects: if isinstance(eff, ObjectFunctionAssignment): results = [] eff.normalize(self.time, results) effects += results else: assert (isinstance(eff, f_expression.FunctionAssignment) or isinstance(eff, conditions.Literal) or isinstance(eff, conditions.ModuleCall) # HACK CHECK ) used_variables = [eff.free_variables()] typed_vars = [] conjunction_parts = [] new_args = [] if isinstance(eff, f_expression.FunctionAssignment): args = [eff.fluent, eff.expression] else: args = eff.args for arg in args: typed, parts, new_arg = arg.compile_objectfunctions_aux( used_variables) typed_vars += typed conjunction_parts += parts new_args.append(new_arg) if len(typed_vars) == 0: effects.append(ConjunctiveEffect([eff], self.time)) else: if isinstance(eff, f_expression.FunctionAssignment): new_eff = eff.__class__(*new_args) else: new_eff = eff.__class__(eff.predicate, new_args) conjunction = conditions.Conjunction(conjunction_parts) if self.time == "start": condition = [ conjunction, conditions.Truth(), conditions.Truth() ] elif self.time == "end": condition = [ conditions.Truth(), conditions.Truth(), conjunction ] else: condition = conjunction cond_eff = ConditionalEffect(condition, new_eff) effects.append( UniversalEffect(typed_vars, cond_eff, self.time)) return TmpEffect(effects)
def dump(self): indent = " " if self.parameters: print "%sforall %s" % (indent, ", ".join(map(str, self.parameters))) indent += " " if ((isinstance(self.condition, list) and self.condition != [conditions.Truth(), conditions.Truth(), conditions.Truth()]) or (not isinstance(self.condition, list) and self.condition != conditions.Truth())): print "%sif" % indent if isinstance(self.condition, list): conditions.dump_temporal_condition(self.condition, indent + " ") else: self.condition.dump(indent + " ") print "%sthen" % indent indent += " " self.peffect.dump(indent)
def dump(self): indent = " " if self.parameters: print "%sforall %s" % (indent, ", ".join(map(str, self.parameters))) indent += " " if self.condition != conditions.Truth(): print "%sif" % indent self.condition.dump(indent + " ") print "%sthen" % indent indent += " " print "%s%s" % (indent, self.literal)
def add_effect(tmp_effect, result): """tmp_effect has the following structure: [ConjunctiveEffect] [UniversalEffect] [ConditionalEffect] SimpleEffect.""" if isinstance(tmp_effect, ConjunctiveEffect): for effect in tmp_effect.effects: add_effect(effect, result) return else: parameters = [] condition = conditions.Truth() if isinstance(tmp_effect, UniversalEffect): parameters = tmp_effect.parameters if isinstance(tmp_effect.effect, ConditionalEffect): condition = tmp_effect.effect.condition assert isinstance(tmp_effect.effect.effect, SimpleEffect) effect = tmp_effect.effect.effect.effect else: assert isinstance(tmp_effect.effect, SimpleEffect) effect = tmp_effect.effect.effect elif isinstance(tmp_effect, ConditionalEffect): condition = tmp_effect.condition assert isinstance(tmp_effect.effect, SimpleEffect) effect = tmp_effect.effect.effect else: assert isinstance(tmp_effect, SimpleEffect) effect = tmp_effect.effect assert isinstance(effect, conditions.Literal) # Check for contradictory effects condition = condition.simplified() new_effect = Effect(parameters, condition, effect) contradiction = Effect(parameters, condition, effect.negate()) if not contradiction in result: result.append(new_effect) else: # We use add-after-delete semantics, keep positive effect if isinstance(contradiction.literal, conditions.NegatedAtom): result.remove(contradiction) result.append(new_effect)
def normalize(self, time, results): used_variables = list(self.head.free_variables() | self.value.free_variables()) typed1, conjunction_parts1, term1 = self.head.compile_objectfunctions_aux( used_variables) typed2, conjunction_parts2, term2 = self.value.compile_objectfunctions_aux( used_variables) assert isinstance(term1, conditions.Variable) add_params = set( [typed for typed in typed1 if not typed.name == term1.name] + typed2) del_params = set(typed1 + typed2) add_conjunction_parts = conjunction_parts1[1:] + conjunction_parts2 del_conjunction_parts = conjunction_parts1 + conjunction_parts2 del_conjunction_parts = conjunction_parts1[1:] + conjunction_parts2 # conjunctive_parts1[0] is left out because we do not need the condition # that the atom in the del effect hast been true before # These conjunction parts are sufficient under the add-after-delete semantics. # Under the consistent effect semantics we need a further condition # that prevents deleting the added predicate. del_param = conjunction_parts1[0].args[-1] del_conjunction_parts.append( conditions.NegatedAtom("=", [del_param, term2])) del_effect = ConjunctiveEffect([ conjunction_parts1[0].negate(), ]) atom_name = conjunction_parts1[0].predicate atom_parts = list(conjunction_parts1[0].args) atom_parts[-1] = term2 add_effect = ConjunctiveEffect([ conditions.Atom(atom_name, atom_parts), ], time) add_conjunction = conditions.Conjunction(add_conjunction_parts) del_conjunction = conditions.Conjunction(del_conjunction_parts) if time == "start": del_condition = [ del_conjunction, conditions.Truth(), conditions.Truth() ] add_condition = [ add_conjunction, conditions.Truth(), conditions.Truth() ] elif time == "end": add_condition = [ conditions.Truth(), conditions.Truth(), add_conjunction ] del_condition = [ conditions.Truth(), conditions.Truth(), del_conjunction ] else: add_condition = add_conjunction del_condition = del_conjunction if len(add_conjunction_parts) > 0: add_effect = ConditionalEffect(add_condition, add_effect, time) del_effect = ConditionalEffect(del_condition, del_effect) if len(add_params) > 0: add_effect = UniversalEffect(add_params, add_effect, time) del_effect = UniversalEffect(del_params, del_effect, time) results.append(add_effect) results.append(del_effect) # value "undefined" must be treated specially because it has not the type # required in del_params if term2.name != "undefined": del_undef_params = set([ typed for typed in del_params if not typed.name == del_param.name ]) atom_parts = list(conjunction_parts1[0].args) atom_parts[-1] = conditions.ObjectTerm("undefined") del_undef_effect = ConjunctiveEffect([ conditions.NegatedAtom(atom_name, atom_parts), ], time) del_undef_conjunction_parts = del_conjunction_parts[:-1] del_undef_conjunction = conditions.Conjunction( del_undef_conjunction_parts) if time == "start": del_undef_condition = [ del_undef_conjunction, conditions.Truth(), conditions.Truth() ] elif time == "end": del_undef_condition = [ conditions.Truth(), conditions.Truth(), del_undef_conjunction ] else: del_undef_condition = del_undef_conjunction if len(del_undef_conjunction_parts) > 0: del_undef_effect = ConditionalEffect(del_undef_condition, del_undef_effect, time) if len(del_undef_params) > 0: del_undef_effect = UniversalEffect(del_undef_params, del_undef_effect, time) results.append(del_undef_effect)