def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
# translate the problem unload actions using example_have_cake.py as example syntax
unloads = []
for a in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr("In({},{})".format(c, p)),
expr("At({}, {})".format(p, a))
]
precond_neg = []
effect_add = [expr("At({}, {})".format(c, a))]
effect_rem = [expr("In({}, {})".format(c, p))]
unload = Action(
expr("Unload({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
# TODO create all Unload ground actions from the domain Unload action
unloads = []
for a in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr("In({}, {})".format(c, p)),
expr("At({}, {})".format(p, a)),
]
precond_neg = []
effect_add = [expr("At({}, {})".format(c, a))]
effect_rem = [expr("In({}, {})".format(c, p))]
unload = Action(
expr("Unload({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def load_actions():
"""Create all concrete Load actions and return a list
:return: list of Action objects
"""
loads = []
for ap in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr("At({}, {})".format(p, ap)),
expr("At({}, {})".format(c, ap)),
]
precond_neg = []
effect_add = [expr("In({}, {})".format(c, p))]
effect_rem = [expr("At({}, {})".format(c, ap))]
load_action = Action(
expr("Load({}, {}, {})".format(c, p, ap)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load_action)
return loads
def fly_actions():
"""Create all concrete Fly actions and return a list
:return: list of Action objects
"""
flys = []
for fr in self.airports:
for to in self.airports:
if fr != to:
for p in self.planes:
precond_pos = [
expr("At({}, {})".format(p, fr)),
]
precond_neg = []
effect_add = [expr("At({}, {})".format(p, to))]
effect_rem = [expr("At({}, {})".format(p, fr))]
fly = Action(
expr("Fly({}, {}, {})".format(p, fr, to)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
flys.append(fly)
return flys
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
all_cargos_planes_airports = ((cargo, plane, airport)
for cargo in self.cargos
for plane in self.planes
for airport in self.airports)
unload_actions_list = []
for cargo, plane, airport in all_cargos_planes_airports:
precond_pos = [
expr("In({}, {})".format(cargo, plane)),
expr("At({}, {})".format(plane, airport))
]
precond_neg = []
effect_add = [expr("At({}, {})".format(cargo, airport))]
effect_rem = [expr("In({}, {})".format(cargo, plane))]
unload = Action(
expr("Unload({}, {}, {})".format(cargo, plane, airport)),
[precond_pos, precond_neg], [effect_add, effect_rem])
unload_actions_list.append(unload)
return unload_actions_list
def load_actions():
"""Create all concrete Load actions and return a list
:return: list of Action objects
"""
# TODO create all load ground actions from the domain Load action
# Action(Load(C, P, A)):
# PRECOND: At(C, A) ^ At(P, A) ^ Cargo(C) ^ Plane(P) ^ Airport(A)
# EFFECT : In(C, P) ^ ¬At(C, A) ^ Cargo(C) ^ Plane(P) ^ Airport(A)
# iterate over all origin and destination airports, planes and cargo, creating concrete action objects
loads = []
for cargo in self.cargos:
for plane in self.planes:
for airport in self.airports:
fluent = expr("Load({}, {}, {})".format(
cargo, plane, airport))
preconds_pos = [
expr("At({}, {})".format(cargo, airport)),
expr("At({}, {})".format(plane, airport))
]
preconds_neg = []
effects_add = [expr("In({}, {})".format(cargo, plane))]
effects_rem = [
expr("At({}, {})".format(cargo, airport))
]
preconds = [preconds_pos, preconds_neg]
effects = [effects_add, effects_rem]
load = Action(fluent, preconds, effects)
loads.append(load)
return loads
def unload_actions():
"""Create all concrete Unload actions and return a list
Action(Unload(c, p, a),
PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a)
EFFECT: At(c, a) ∧ ¬ In(c, p))
:return: list of Action objects
"""
unloads = []
# create combinations of all cargos, planes and airports
# to generate all possible unload actions
for cargo in self.cargos:
for plane in self.planes:
for airport in self.airports:
# generate action precodnitions and effects
# in predefined format (see method docs)
precond_pos = [
expr("In({}, {})".format(cargo, plane)),
expr("At({}, {})".format(plane, airport))
]
precond_neg = []
effect_add = [
expr("At({}, {})".format(cargo, airport))
]
effect_rem = [expr("In({}, {})".format(cargo, plane))]
# create action and append it to all other unload actions
unload = Action(
expr("Unload({}, {}, {})".format(
cargo, plane,
airport)), [precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def load_actions():
'''Create all concrete Load actions and return a list
:return: list of Action objects
'''
loads = []
# TODO create all load ground actions from the domain Load action
for a in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr('At({}, {})'.format(c, a)),
expr('At({}, {})'.format(p, a)),
]
precond_neg = []
effect_add = [expr('In({}, {})'.format(c, p))]
effect_rem = [expr('At({}, {})'.format(c, a))]
load_action = Action(
expr('Load({}, {}, {})'.format(c, a, p)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load_action)
return loads
def load_actions():
'''Create all concrete Load actions and return a list
Action(Load(c, p, a),
PRECOND: At(c, a) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a)
EFFECT: ¬ At(c, a) ∧ In(c, p))
:return: list of Action objects
'''
loads = []
# TODO create all load ground actions from the domain Load action
for a in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr("At({}, {})".format(p, a)),
expr("At({}, {})".format(c, a)),
]
precond_neg = []
effect_add = [expr("In({}, {})".format(c, p))]
effect_rem = [expr("At({}, {})".format(c, a))]
load = Action(expr("Load({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load)
return loads
def unload_actions():
"""Create all concrete Unload actions and return a list
Action(Unload(c, p, a),
PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a)
EFFECT: At(c, a) ∧ ¬ In(c, p))
:return: list of Action objects
"""
unloads = []
for c in self.cargos:
for a in self.airports:
for p in self.planes:
precond_pos = [
expr("At({}, {})".format(p, a)),
expr("In({}, {})".format(c, p))
]
precond_neg = []
effect_add = [expr("At({}, {})".format(c, a))]
effect_rem = [expr("In({}, {})".format(c, p))]
unload = Action(
expr("Unload({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def unload_actions():
'''Create all concrete Unload actions and return a list
:return: list of Action objects
'''
unloads = []
for cargo, plane, airport in product(self.cargos, self.planes,
self.airports):
precond_pos = [
expr(f"In({cargo}, {plane})"),
expr(f"At({plane}, {airport})")
]
precond_neg = []
effect_add = [expr(f"At({cargo}, {airport})")]
effect_rem = [expr(f"In({cargo}, {plane})")]
unload = Action(expr(f"Unload({cargo}, {plane}, {airport})"),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def load_actions():
"""Create all concrete Load actions and return a list
:return: list of Action objects
"""
loads = []
# TODO create all load ground actions from the domain Load action
####Implement this function
for a in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr("At({}, {})".format(p, a)),
expr("At({}, {})".format(c, a)),
]
precond_neg = []
effect_add = [expr("In({}, {})".format(c, p))]
effect_rem = [expr("At({}, {})".format(c, a))]
load = Action(expr("Load({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load)
return loads
def load_actions():
"""Create all concrete Load actions and return a list
:return: list of Action objects
"""
loads = []
cargos = self.cargos
planes = self.planes
airports = self.airports
for i in range(len(self.cargos)):
for j in range(len(self.planes)):
for k in range(len(self.airports)):
#ca_index = self.state_map.index(expr("At({}, {})".format(cargos[i], airports[k])))
#if self.initial_state_TF[ca_index] == 'T':
#pa_index = self.state_map.index(expr("At({}, {})".format(planes[j], airports[k])))
#if self.initial_state_TF[pa_index] == 'T':
precond_pos = [
expr("At({}, {})".format(cargos[i], airports[k])),
expr("At({}, {})".format(planes[j], airports[k]))
]
precond_neg = []
#precond_neg = [expr("In({}, {})".format(cargos[i], planes[j]))]
effect_add = [
expr("In({}, {})".format(cargos[i], planes[j]))
]
effect_rem = [
expr("At({}, {})".format(cargos[i], airports[k]))
]
load = Action(
expr("Load({}, {}, {})".format(
cargos[i], planes[j],
airports[k])), [precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load)
return loads
def unload_actions():
'''Create all concrete Unload actions and return a list
:return: list of Action objects
'''
unloads = []
for element in itertools.product(self.cargos, self.planes, self.airports):
cargo, plane, airport = element
precond_pos = [expr("%s(%s,%s)"%(self._AT, plane, airport))]
precond_pos.append(expr("%s(%s,%s)"%(self._IN, cargo, plane)))
precond_pos.append(expr("%s(%s)"%(self._CARGO, cargo)))
precond_pos.append(expr("%s(%s)"%(self._AIRPORT, airport)))
precond_pos.append(expr("%s(%s)"%(self._PLANE, plane)))
precond_neg = []
effect_add = [expr("%s(%s,%s)"%(self._AT, cargo, airport))]
effect_rem = [expr("%s(%s,%s)"%(self._IN, cargo, plane))]
action_e = expr("%s(%s,%s)"%(self._UNLOAD, cargo, plane))
action = Action(action_e, [precond_pos, precond_neg], [effect_add, effect_rem])
unloads.append(action)
return unloads
def fly_actions():
'''Create all concrete Fly actions and return a list
:return: list of Action objects
'''
flys = []
for element in itertools.product(self.planes, self.airports, self.airports):
plane, from_a, to_a = element
if from_a == to_a:
continue;
precond_pos = [expr("%s(%s,%s)"%(self._AT, plane, from_a))]
precond_pos.append(expr("%s(%s)"%(self._PLANE, plane)))
precond_pos.append(expr("%s(%s)"%(self._AIRPORT, to_a)))
precond_pos.append(expr("%s(%s)"%(self._AIRPORT, from_a)))
precond_neg = []
effect_rem = [expr("%s(%s,%s)"%(self._AT, plane, from_a))]
effect_add = [expr("%s(%s,%s)"%(self._AT, plane, to_a))]
action_e = expr("%s(%s,%s,%s)"%(self._FLY, plane, from_a, to_a))
action = Action(action_e, [precond_pos, precond_neg], [effect_add, effect_rem])
flys.append(action)
return flys
def unload_actions():
"""Create all concrete Unload actions as a list:
Unload(c, p, a),
PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a)
EFFECT: At(c, a) ∧ ¬ In(c, p)
:return: list of Action objects
"""
unloads = []
for airport in self.airports:
for plane in self.planes:
for cargo in self.cargos:
precond_pos = [
expr("In({},{})".format(cargo, plane)),
expr("At({},{})".format(plane, airport))
]
precond_neg = []
effect_pos = [expr("At({},{})".format(cargo, airport))]
effect_rem = [expr("In({},{})".format(cargo, plane))]
action = expr("Unload({},{},{})".format(
cargo, plane, airport))
unload = Action(action, [precond_pos, precond_neg],
[effect_pos, effect_rem])
unloads.append(unload)
return unloads
def load_actions():
"""Create all concrete Load actions and return a list
:return: list of Action objects
"""
loads = []
# TODO create all load ground actions from the domain Load action
# Form triplets of cargo, planes, airports
cta_list = [(cur_cargo, cur_plane, cur_airport)
for cur_airport in self.airports
for cur_plane in self.planes
for cur_cargo in self.cargos]
# Build all possible actions
for cargo, plane, air in cta_list:
# Positive preconditions
# (no negative preconditions)
pos_prec = [
expr("At({}, {})".format(cargo, air)),
expr("At({}, {})".format(plane, air))
]
add_effect = [expr("In({}, {})".format(cargo, plane))]
rem_effect = [expr("At({}, {})".format(cargo, air))]
# Empty list for negative preconditions
# Build complete Action
cur_load = Action(
expr("Load({}, {}, {})".format(cargo, plane, air)),
[pos_prec, []], [add_effect, rem_effect])
loads.append(cur_load)
return loads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
# initialize unloads list
unloads = []
# TODO create all Unload ground actions from the domain Unload action
# for each cargo
for c in self.cargos:
# for each plane
for p in self.planes:
# for each airport
for a in self.airports:
# PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a)
precond_pos = [
expr("In({}, {})".format(c, p)),
expr("At({}, {})".format(p, a))
]
# precondition negative
precond_neg = []
# EFFECT: At(c, a) ∧ ¬ In(c, p))
# effect add, cargo at airport, At(c, a)
effect_add = [expr("At({}, {})".format(c, a))]
# effect remove, cargo not in plane, ¬ In(c, p)
effect_rem = [expr("In({}, {})".format(c, p))]
# action unload(cargo, plane, airport), preconditions, effects
unload = Action(
expr("Unload({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
# append unload action objects
unloads.append(unload)
# return list of unload action objects
return unloads
def load_actions():
'''Create all concrete Load actions and return a list
:return: list of Action objects
'''
loads = []
# Get all combinations of cargo, airports, and planes
for cargo, plane, airport in product(self.cargos, self.planes,
self.airports):
precond_pos = [
expr(f"At({cargo}, {airport})"),
expr(f"At({plane}, {airport})")
]
precond_neg = []
effect_add = [expr(f"In({cargo}, {plane})")]
effect_rem = [expr(f"At({cargo}, {airport})")]
load = Action(expr(f"Load({cargo}, {plane}, {airport})"),
[precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load)
return loads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
unloads = []
all_pairs = [(cargo, plane, airport) for cargo in self.cargos
for plane in self.planes for airport in self.airports]
for (cargo, plane, airport) in all_pairs:
precond_pos = [
expr("In({}, {})".format(cargo, plane)),
expr("At({}, {})".format(plane, airport))
]
precond_neg = []
effect_add = [expr("At({}, {})".format(cargo, airport))]
effect_rem = [expr("In({}, {})".format(cargo, plane))]
action = Action(
expr("Unload({}, {}, {})".format(cargo, plane, airport)),
[precond_pos, precond_neg], [effect_add, effect_rem])
unloads.append(action)
return unloads
def load_actions():
'''Create all concrete Load actions and return a list
:return: list of Action objects
'''
loads = []
for cargo in self.cargos:
for plane in self.planes:
for airport in self.airports:
precond_pos = [
expr("At({}, {})".format(cargo, airport)),
expr("At({}, {})".format(plane, airport))
]
precond_neg = []
effect_add = [expr("In({}, {})".format(cargo, plane))]
effect_rem = [
expr("At({}, {})".format(cargo, airport))
]
load = Action(
expr("Load({}, {}, {})".format(
cargo, plane,
airport)), [precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load)
return loads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
unloads = []
# TODO create all Unload ground actions from the domain Unload action
for apt in self.airports:
for pl in self.planes:
for crg in self.cargos:
precond_pos = [
expr("At({},{})".format(pl, apt)),
expr("In({},{})".format(crg, pl))
]
precond_neg = []
effect_add = [expr("At({},{})".format(crg, apt))]
#effect_rem = [expr("At({},{})".format(pl, apt))]
effect_rem = [expr("In({},{})".format(crg, pl))]
unload_act = Action(
expr("Unload({},{},{})".format(crg, pl, apt)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload_act)
return unloads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
# TODO create all Unload ground actions from the domain Unload action
# Action(Unload(c, p, a),
# PRECOND: In(c, p) ∧ At(p, a) ∧ Cargo(c) ∧ Plane(p) ∧ Airport(a)
# EFFECT: At(c, a) ∧ ¬ In(c, p))
# iterate over all origin and destination airports planes and cargo, creating concrete action objects
unloads = []
for cargo in self.cargos:
for plane in self.planes:
for airport in self.airports:
fluent = expr("Unload({}, {}, {})".format(
cargo, plane, airport))
preconds_pos = [
expr("In({}, {})".format(cargo, plane)),
expr("At({}, {})".format(plane, airport))
]
preconds_neg = []
effects_add = [
expr("At({}, {})".format(cargo, airport))
]
effects_rem = [expr("In({}, {})".format(cargo, plane))]
preconds = [preconds_pos, preconds_neg]
effects = [effects_add, effects_rem]
unload = Action(fluent, preconds, effects)
unloads.append(unload)
return unloads
def unload_actions():
"""Create all concrete Unload actions
Returns
-------
collection of Action objects
"""
unloads = []
for c in self.cargos:
for p in self.planes:
for a in self.airports:
precond_pos = set([
expr("In({}, {})".format(c, p)),
expr("At({}, {})".format(p, a)),
])
precond_neg = set([])
effect_add = set([expr("At({}, {})".format(c, a))])
effect_rem = set([expr("In({}, {})".format(c, p))])
unload = Action(
expr("Unload({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def fly_actions():
'''Create all concrete Fly actions and return a list
Action(Fly(p, from, to),
PRECOND: At(p, from) ∧ Plane(p) ∧ Airport(from) ∧ Airport(to)
EFFECT: ¬ At(p, from) ∧ At(p, to))
:return: list of Action objects
'''
flys = []
for fr in self.airports:
for to in self.airports:
if fr != to:
for p in self.planes:
precond_pos = [
expr("At({}, {})".format(p, fr)),
]
precond_neg = []
effect_add = [expr("At({}, {})".format(p, to))]
effect_rem = [expr("At({}, {})".format(p, fr))]
fly = Action(
expr("Fly({}, {}, {})".format(p, fr, to)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
flys.append(fly)
return flys
def fly_actions():
"""Create all concrete Fly actions
Returns
-------
collection of Action objects
"""
flys = []
for fr in self.airports:
for to in self.airports:
if fr != to:
for p in self.planes:
precond_pos = set([expr("At({}, {})".format(p, fr)), \
])
precond_neg = set([])
effect_add = set(
[expr("At({}, {})".format(p, to))])
effect_rem = set(
[expr("At({}, {})".format(p, fr))])
fly = Action(expr("Fly({}, {}, {})".format(p, fr, to)), \
[precond_pos, precond_neg], \
[effect_add, effect_rem])
flys.append(fly)
return flys
def unload_actions():
'''Create all concrete Unload actions and return a list
:return: list of Action objects
'''
unloads = []
for fr in self.airports:
for p in self.planes:
for c in self.cargos:
precond_pos = [
expr("At({}, {})".format(p, fr)),
expr("In({}, {})".format(c, p)),
]
precond_neg = []
effect_add = [expr("At({}, {})".format(c, fr))]
effect_rem = [expr("In({}, {})".format(c, p))]
unload = Action(
expr("Unload({}, {}, {})".format(c, p, fr)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
return unloads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
unloads = []
# create all Unload ground actions from the domain Unload action
for c in self.cargos:
for p in self.planes:
for a in self.airports:
precond_pos = [
expr("In({}, {})".format(c, p)),
expr("At({}, {})".format(p, a))
]
precond_neg = []
effect_add = [expr("At({}, {})".format(c, a))]
effect_rem = [expr("In({}, {})".format(c, p))]
unload = Action(
expr("Unload({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
unloads.append(unload)
#print("# of unloads:",len(set([(unload.name,unload.args) for unload in unloads])))
return unloads
def unload_actions():
"""Create all concrete Unload actions and return a list
:return: list of Action objects
"""
unloads = []
# TODO create all Unload ground actions from the domain Unload action
for cargo in self.cargos:
for airoport in self.airports:
for plane in self.planes:
precond_pos = [
expr("In({}, {})".format(cargo, plane)),
expr("At({},{})".format(plane, airoport))
]
effect_add = [
expr("At({},{})".format(cargo, airoport))
]
effect_rem = [expr("In({},{})".format(cargo, plane))]
unloads.append(
Action(
expr("Unload({},{},{})".format(
cargo, plane, airoport)),
[precond_pos, []], [effect_add, effect_rem]))
return unloads
def load_actions():
"""Create all concrete Load actions and return a list
:return: list of Action objects
"""
loads = []
for a in self.airports:
for p in self.planes:
for c in self.cargos:
# cargo c and plane p must be on airport a, cargo c, plane p, and airport must be exist
precond_pos = [
expr('At({}, {})'.format(c, a)),
expr('At({}, {})'.format(p, a))
]
precond_neg = []
# load cargo c to plane p
effect_add = [expr('In({}, {})'.format(c, p))]
# remove cargo c from airport a
effect_rem = [expr('At({}, {})'.format(c, a))]
load = Action(expr("Load({}, {}, {})".format(c, p, a)),
[precond_pos, precond_neg],
[effect_add, effect_rem])
loads.append(load)
return loads