def add_operator_transitions(operator, transitions):
for variable, (start, end) in transitions.items():
if start is not None:
operator.conditions.append(
SubstateCondition(Substate({variable: start})))
if end is not None:
operator.effects[variable] = ValueEffect(end)
def restack(n=10, height=5):
blocks = ['B%d'%i for i in range(1, n+1)]
start = State(merge_dicts(
{('on', blocks[0]): 'table', ('clear', blocks[height-1]): True},
{('on', blocks[i+1]): blocks[i] for i in range(height-1)},
{('on', blocks[i]): 'table' for i in range(height, n)},
{('clear', blocks[i]): True for i in range(height, n)}
))
goal = PartialState([
SubstateCondition(Substate({('on', blocks[i]): blocks[i+1]})) for i in range(height-1)] + [
SubstateCondition(Substate({('on', blocks[height-1]): 'table'}))
])
actions = [Pick(item) for item in blocks] + [Place(item) for item in blocks] + \
[Unstack(*item) for item in permutations(blocks, 2)] + [Stack(*item) for item in permutations(blocks, 2)]
return start, goal, lambda rg: InitDiscreteScheduler(rg, actions)
def edge(self, value): # intermediates=set()
if value not in self.edges:
edge = Edge(value, self)
self.edges[value] = edge
for condition in value.conditions:
self.connector(condition).connect(edge)
if CONNECT_EFFECTS and hasattr(value, 'effects'):
for variable, effect in value.effects.iteritems():
if isinstance(effect, ValueEffect):
edge.connect(self.vertex(Substate({variable: effect.value})))
return self.edges[value]
def add_achiever(self, action, goal_connector):
assert all(
isinstance(eff, ValueEffect) for eff in action.effects.values())
effect_vertex = self.vertex(
Substate({
var: value
for var, value in action.fixed_image().items()
if var in goal_connector.condition.variables
})) # TODO - conditional effects
#if action in self.edges: return False # Returns false for existing actions
if goal_connector.satisfies(effect_vertex):
edge = self.edge(action)
if effect_vertex.connected(goal_connector) and edge.connected(
effect_vertex, source_vertex=None):
return False
effect_vertex.connect(goal_connector)
edge.connect(effect_vertex)
else:
print(action, goal_connector)
raise RuntimeError('Action does not achieve goal') # TODO - remove
return True
def set_active(self):
if self.active: return
if self.rg.greedy and self.reachable: return # NOTE - recently added
self.active = True
self.activations += 1
start = self.rg.start
if start in self.condition:
start_vertex = self.rg.vertex(
Substate({
var: self.rg.start[var]
for var in self.condition.variables
}))
start_vertex.connect(self)
#self.rg.start.connect(self)
return
if self.subplanners[start] is None:
# TODO - decide to first generate only new subplanners or all
# TODO - remove dependence of subplanners on Vertex start
self.subplanners[start] = self.rg.scheduler(
Vertex(start, self.rg), self
) # Eventually will just take a connector (which is implicitly relative to the start)
for subplanner in self.subplanners[start]:
subplanner.creation = self.rg.state_uses[start]
subplanner.generation_history = defaultdict(int)
for subplanner in self.subplanners[start]:
if not subplanner.exhausted and not subplanner.queued:
if INITIAL_GENERATION:
subplanner()
if subplanner.exhausted: continue
self.rg.queue.append(subplanner)
subplanner.queued = True
for vertex in self.vertices:
vertex.set_active()
def connect_discrete_effects(rg, edge):
for variable, effect in edge.value.effects.items():
if is_discrete_effect(effect):
vertex = rg.vertex(Substate({variable: effect.value}))
edge.connect(vertex)