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)