def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) new_state_st = encode_state(new_state, self.state_map) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ fluent_state=decode_state(state, self.state_map) pos = [x for x in (fluent_state.pos + action.effect_add) if x not in action.effect_rem] neg = [x for x in (fluent_state.neg + action.effect_rem) if x not in action.effect_add] new_state = FluentState(pos, neg) return encode_state(new_state, self.state_map)
def __init__(self, cargos, planes, airports, initial: FluentState, goal: list): """ :param cargos: list of str cargos in the problem :param planes: list of str planes in the problem :param airports: list of str airports in the problem :param initial: FluentState object positive and negative literal fluents (as expr) describing initial state :param goal: list of expr literal fluents required for goal test """ self.state_map = initial.pos + initial.neg self.initial_state_TF = encode_state(initial, self.state_map) Problem.__init__(self, self.initial_state_TF, goal=goal) self.cargos = cargos self.planes = planes self.airports = airports self.actions_list = self.get_actions()
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) kb = PropKB() kb.tell(decode_state(state, self.state_map).pos_sentence()) action(kb, action.args) for clause in kb.clauses: new_state.pos.append(clause) for clause in action.effect_rem: new_state.neg.append(clause) return encode_state(new_state, self.state_map)
def __init__(self, cargos, planes, airports, initial: FluentState, goal: list): """ :param cargos: list of str cargos in the problem :param planes: list of str planes in the problem :param airports: list of str airports in the problem :param initial: FluentState object positive and negative literal fluents (as expr) describing initial state :param goal: list of expr literal fluents required for goal test """ self.state_map = initial.pos + initial.neg self.initial_state_TF = encode_state(initial, self.state_map) Problem.__init__(self, self.initial_state_TF, goal=goal) self.cargos = cargos self.planes = planes self.airports = airports self.actions_list = self.get_actions()
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) old_state = decode_state(state, self.state_map) new_state.pos.extend(f for f in old_state.pos if f not in action.effect_rem) new_state.pos.extend(f for f in action.effect_add if f not in new_state.pos) new_state.neg.extend(f for f in old_state.neg if f not in action.effect_add) new_state.neg.extend(f for f in action.effect_rem if f not in new_state.neg) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # Lifted from example_have_cake.py new_state = FluentState([], []) # Get the current state old_state = decode_state(state, self.state_map) # Per the teaching materials, the precondition and effect of an action are each conjunctions of literals # (positive or negated atomic sentences). The precondition defines the states in which the action can be # executed, and the effect defines the result of executing the action. So, for each fluent (positive or # negative) in the old state, we need to look in the action's effects (both the add and remove effects) to # determine how the fluent will be carried over to the new state, as a positive or a negative fluent. for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) # The action may have positive and negative effects INDEPENDENTLY of the old state. If they're add effects, # we need to make sure these fluents are added to the new state's positive sentences. Similarly, if they're # remove effects, these fluents need to be added to the new state's negative sentences. for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) # Return the new state return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ current_state = decode_state(state, self.state_map) new_pos = set(current_state.pos) new_neg = set(current_state.neg) for add in action.effect_add: new_pos.add(add) new_neg.discard(add) for rem in action.effect_rem: new_pos.discard(rem) new_neg.add(rem) return encode_state(FluentState(list(new_pos), list(new_neg)), self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append( fluent ) # add positive fluents which are in the old state and should not be removed for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append( fluent ) # add positive fluents which should be added and have not already been added for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append( fluent ) # add negative fluents which are in the old state and should not be added for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append( fluent ) # add negative fluents which should be removed but have not already been removed from the negative state return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Returns the state that results from executing the given action in the given state. The action is one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) old_state = decode_state(state, self.state_map) # If a positive fluent has not been removed by the effect of current action then # append that to positive fluents in the new_state. for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) # If a new positive fluent is added by the effect of current action then # append that to positive fluents in the new_state. for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) # If a negative fluent has not been removed by the effect of current action then # append that to negative fluents in the new_state. for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append # If a negative fluent has been removed by the effect of current action then # append that to negative fluents in the new_state. for fluents in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement # Get the current state curr_state = decode_state(state, self.state_map) new_state = FluentState([], []) # For each fluent in current state, we need to check the action's effects (added or removed effects), # in order to how the positive or negative fluent can be carried over to the new state. for f in curr_state.neg: if f not in action.effect_add: new_state.neg.append(f) for f in curr_state.pos: if f not in action.effect_rem: new_state.pos.append(f) # The action may have positive and negative effects separated, e.g. we need to check if the fluents are # added to the new state's positive clauses if the actions have add effects. It is also the same for negative # clauses for f in action.effect_rem: if f not in new_state.neg: new_state.neg.append(f) for f in action.effect_add: if f not in new_state.pos: new_state.pos.append(f) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) #This code is used from Cake example file #The idea of this function is to define next state in our problem #which is going to "happen" after applying current action old_state = decode_state(state, self.state_map) #Going through positive fluents in previous (old) state for fluent in old_state.pos: #if that fluent is not in removal_effect from action -> add it to positve fluents for new state if fluent not in action.effect_rem: new_state.pos.append(fluent) #going through fluents that are added by the action for fluent in action.effect_add: #if that fluent is not already in positive fluents of new state -> add it if fluent not in new_state.pos: new_state.pos.append(fluent) #going through negative fluents from old state for fluent in old_state.neg: #if that negative fluent is not in adding fluents of the action -> add it to negative fluents for new state if fluent not in action.effect_add: new_state.neg.append(fluent) #going through fluents that are being removed by the action for fluent in action.effect_rem: #if that fluent is not already in negatives for the new state -> add it if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). This routine simply takes the current state, pos and neg, and copies to a new version depending on the action's effects which can be add or rem. So if the action has a add effect the new state will contain that effect in its pos section If the action has a rem effect then the new state will contain that effect in its neg section More formally put (p368) - The result of executing action a in state s is defined as a state s' which is represented by the set of fluents formed by starting with s, removing the fluents that appear as negative literals in the action's effects (what we wil call the delete list or DEL(a), and addign the fluents that are positie literals in the action's effects (what we will call the add list or ADD(a). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement #print('Running result() function...') new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for pos_fluent in old_state.pos: if pos_fluent not in action.effect_rem: # positive effect new_state.pos.append(pos_fluent) for pos_fluent in action.effect_add: # negative effect if pos_fluent not in new_state.pos: new_state.pos.append(pos_fluent) for neg_fluent in old_state.neg: if neg_fluent not in action.effect_add: # negative effect new_state.neg.append(neg_fluent) for neg_fluent in action.effect_rem: # positive effect if neg_fluent not in new_state.neg: new_state.neg.append(neg_fluent) ''' old_state = decode_state(state, self.state_map) pos, neg = set(old_state.pos), set(old_state.neg) pos = pos - set(action.effect_rem) | set(action.effect_add) neg = neg - set(action.effect_add) | set(action.effect_rem) new_state = FluentState(list(pos), list(neg)) ''' return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # This from example_have_cake.py should work new_state = FluentState([], []) old_state = decode_state(state, self.state_map) """ for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) """ # This may be a better way, how much depends on the size pos_fluents = set(old_state.pos) pos_fluents.difference_update(action.effect_rem) pos_fluents.update(action.effect_add) new_state.pos.extend(pos_fluents) neg_fluents = set(old_state.neg) neg_fluents.difference_update(action.effect_add) neg_fluents.update(action.effect_rem) new_state.neg.extend(neg_fluents) #""" return encode_state(new_state, self.state_map)
def process_actions(self, state): ''' This function is called recursively to process all action for a state, each state will be counted as one, and the total will indicate how many actions/states are processed to reach the goal, ignoring the preconditions :param state: :return: count of states to reach a goal ''' count = 1 actions = self.actions(state) fluent_state = decode_state(state, self.state_map) # assume all actions are effective regardless and add them to the state. for action in actions: for fluent in action.effect_add: if fluent not in fluent_state.pos: fluent_state.pos.append(fluent) if fluent in fluent_state.neg: fluent_state.neg.remove(fluent) new_state = encode_state(fluent_state, self.state_map) if not self.goal_test(new_state): count += self.process_actions(new_state) return count
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for positive in old_state.pos: if positive in action.effect_rem: new_state.neg.append(positive) else: new_state.pos.append(positive) for negative in old_state.neg: if negative in action.effect_add: new_state.pos.append(negative) else: new_state.neg.append(negative) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ temp_pos = decode_state(state, self.state_map).pos temp_neg = decode_state(state, self.state_map).neg # remove negative literals and add positive literals for add_val in action.effect_add: temp_pos.append(add_val) temp_neg.remove(add_val) for rem_val in action.effect_rem: temp_pos.remove(rem_val) temp_neg.append(rem_val) return encode_state(FluentState(temp_pos, temp_neg), self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = decode_state(state, self.state_map) for eff in action.effect_add: if eff in new_state.neg: new_state.neg.remove(eff) new_state.pos.append(eff) for eff in action.effect_rem: if eff in new_state.pos: new_state.pos.remove(eff) new_state.neg.append(eff) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). Checks for fluents that are positive in the old stat and are not in the remove list of the actions. Later checks for negative fluents in the old state that not present in the effect_add list of the action Finally check for add effects of the action that are not in the restul, end the rem effects that :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) old_state = decode_state(state, self.state_map) # Add not exisiting positive state and remove exsiting negative state for fluent in old_state.pos: if fluent not in new_state.pos: new_state.pos.append(fluent) if fluent in new_state.neg: new_state.neg.remove(fluent) for fluent in old_state.neg: if fluent in new_state.pos: new_state.pos.remove(fluent) if fluent not in new_state.neg: new_state.neg.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) if fluent in new_state.neg: new_state.neg.remove(fluent) for fluent in action.effect_rem: if fluent in new_state.pos: new_state.pos.remove(fluent) if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement # check whether the action is in the action list isValidAction = False for act in self.actions_list: if (action.name == act.name) and (action.args == act.args): isValidAction = True break if not isValidAction: raise ValueError("Invalid action!") newPos = [] newNeg = [] for i, char in enumerate(state): if char == 'T': newPos.append(self.state_map[i]) else: newNeg.append(self.state_map[i]) for add in action.effect_add: newPos.append(add) newNeg.remove(add) for rem in action.effect_rem: newPos.remove(rem) newNeg.append(rem) new_state = FluentState(newPos, newNeg) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # Decode Bool string into its conditions fState = decode_state(state, self.state_map) # Create NewState with the same Conds. as the current # - !copy(): decode_state() already creates new lists new_state = FluentState(fState.pos, fState.neg) # Loop:: iter=0: True Effects; iter=1: Not Effects for iter in range(2): # Using True Effects if iter == 0: actEft = action.effect_add # True Effects stateEftAdd = new_state.pos # Add New State Pos. stateEftRemove = new_state.neg # Remove New State Neg. # Using Not Effects else: actEft = action.effect_rem # Not Effects stateEftAdd = new_state.neg # Add New State Neg. stateEftRemove = new_state.pos # Remove New State Pos. # Loop by Effects of that Set for effect in actEft: stateEftAdd.append( effect) # NewState Add Effect to same Polar sign Set stateEftRemove.remove( effect ) # NewState Remove Effect from opposite Polar sign Set # Encode into Bool String return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement new_state = FluentState([], []) current_state = decode_state(state, self.state_map) for pos in current_state.pos: if pos not in new_state.pos: new_state.pos.append(pos) if pos in new_state.neg: new_state.neg.remove(pos) for neg in current_state.neg: if neg in new_state.pos: new_state.pos.remove(neg) if neg not in new_state.neg: new_state.neg.append(neg) for add in action.effect_add: if add not in new_state.pos: new_state.pos.append(add) if add in new_state.neg: new_state.neg.remove(add) for rem in action.effect_rem: if rem in new_state.pos: new_state.pos.remove(rem) if rem not in new_state.neg: new_state.neg.append(rem) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) old_state = decode_state(state, self.state_map) #In the new state after action is done on old state #the positive fluents in old state will be added to new state as #it is if those fluents are not to be removed by negative effects of action. # Thus we do.. for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) #also add "new" fluents to the new state which #are present in add effect of the action for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) #in the new state, the negative fluents in old state #will be added to new state's negative fluents if those fluents #are not present in positive effect of action. Thus.. for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) #in new state, the negative fluents will be added as #it is from negative action fluents if these fluents #are not already present in negative fluents list... for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # TODO implement useless = decode_state(state, self.state_map) pos = useless.pos neg = useless.neg for pc in action.effect_add: pos.append(pc) if pc in neg: neg.remove(pc) for pc in action.effect_rem: neg.append(pc) pos.remove(pc) new_state = FluentState(pos, neg) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ # define the resulting state resulting_state = FluentState([], []) # the previous state p_state = decode_state(state, self.state_map) for fluent in p_state.pos: if fluent not in action.effect_rem: # each positive fluent not removed by my action, stays in the resulting state resulting_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in resulting_state.pos: # each effect added by my action that is not in the resulting state yet, has to be added resulting_state.pos.append(fluent) for fluent in p_state.neg: if fluent not in action.effect_add: # every negative fluent that was not affected by my action is still applied to the resulting state resulting_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in resulting_state.neg: # every negative effect my action will have has to be added to my resulting state, # if is not already there resulting_state.neg.append(fluent) return encode_state(resulting_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) for possible_action in (possible_action for possible_action in self.actions(state) if (action.name == possible_action.name and action.args == possible_action.args)): pos_state = decode_state(state, self.state_map).pos neg_state = decode_state(state, self.state_map).neg for new_state_pos in action.effect_add: pos_state.append(new_state_pos) neg_state.remove(new_state_pos) for new_state_neg in action.effect_rem: pos_state.remove(new_state_neg) neg_state.append(new_state_neg) new_state = FluentState(pos_state, neg_state) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ #Initialize new instance of FluentState new_state = FluentState([], []) #Read entering state old_state = decode_state(state, self.state_map) #Check if positive fluents in the entering state have been affected for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) #Add new positive fluents from the action's effects for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) #Check if there are negative fluents in old state not affected by action for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) #Add to negative fluents those removed by action's effects for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied def fly_actions(): :return: resulting state after action """ new_state = FluentState([], []) old_state = decode_state(state, self.state_map) for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) return encode_state(new_state, self.state_map)
def result(self, state: str, action: Action): """ Return the state that results from executing the given action in the given state. The action must be one of self.actions(state). :param state: state entering node :param action: Action applied :return: resulting state after action """ new_state = FluentState([], []) ## Initialize new state old_state = decode_state(state, self.state_map) ## Extract the old state for fluent in old_state.pos: if fluent not in action.effect_rem: new_state.pos.append(fluent) ## Append +ve fluents from old state that don't require removal for fluent in action.effect_add: if fluent not in new_state.pos: new_state.pos.append(fluent) ## Append +ve fluents from old state that require addition for fluent in old_state.neg: if fluent not in action.effect_add: new_state.neg.append(fluent) ## Refer to comments above but with -ve fluents for fluent in action.effect_rem: if fluent not in new_state.neg: new_state.neg.append(fluent) ## Refer to comments above but with -ve fluents return encode_state(new_state, self.state_map) ## Encode the new state
def __init__(self, cargos, planes, airports, initial: FluentState, goal: list): """ :param cargos: list of str cargos in the problem :param planes: list of str planes in the problem :param airports: list of str airports in the problem :param initial: FluentState object positive and negative literal fluents (as expr) describing initial state :param goal: list of expr literal fluents required for goal test """ self.state_map = initial.pos + initial.neg self.initial_state_TF = encode_state(initial, self.state_map) print('Now in AirCargoProblem initiation...',self.state_map, self.initial_state_TF,goal,'preparing to call problem.__init__') Problem.__init__(self, self.initial_state_TF, goal=goal) self.cargos = cargos print('Back in AirCargoProblem()........cargos,planes and airports..',cargos,planes,airports) self.planes = planes self.airports = airports self.actions_list = self.get_actions() #CALL MY ROUTINES TO BUILD LIST OF ACTIONS
def __init__(self, cargos, planes, airports, initial: FluentState, goal: list): """ :param cargos: list of str cargos in the problem :param planes: list of str planes in the problem :param airports: list of str airports in the problem :param initial: FluentState object positive and negative literal fluents (as expr) describing initial state :param goal: list of expr literal fluents required for goal test """ self.state_map = initial.pos + initial.neg #state_map is list of [expr(..),..] self.initial_state_TF = encode_state(initial, self.state_map) #TFTFFFTT Problem.__init__(self, self.initial_state_TF, goal=goal) #not understand self.cargos = cargos #['C1', 'C2'] self.planes = planes #['P1', 'P2'] self.airports = airports #['JFK', 'SFO'] self.actions_list = self.get_actions()
def __init__(self, initial: FluentState, goal: list): self.state_map = initial.pos + initial.neg Problem.__init__(self, encode_state(initial, self.state_map), goal=goal) self.actions_list = self.get_actions()