/// <summary> /// Initialises the competence element. /// /// The log domain is set to [AgentName].CE.[element_name]. /// </summary> /// <param name="agent">The competence element's agent.</param> /// <param name="elementName">The name of the competence element.</param> /// <param name="trigger">The element's trigger</param> /// <param name="element">The element to fire (Action,Competence or ActionPattern).</param> /// <param name="maxRetries">The maximum number of retires. If this is set /// to a negative number, it is ignored.</param> public CompetenceElement(Agent agent, string elementName, Trigger trigger, CopiableElement element, int maxRetries) : base(string.Format("CE.{0}", elementName), agent) { this.name = elementName; this.trigger = trigger; this.element = element; this.maxRetries = maxRetries; this.retries = 0; log.Debug("Created"); }
/// <summary> /// Initialises the result of firing an element. /// /// For a more detailed description of the arguments, read the /// class documentation. /// </summary> /// <param name="continueExecution">If we want to continue executing the current /// part of the plan.</param> /// <param name="nextElement">The next plan element to fire.</param> public FireResult(bool continueExecution, CopiableElement nextElement) { continueExecuting = continueExecution; if (continueExecution && nextElement is CopiableElement) { // copy the next element, if there is one next = (ElementCollection)nextElement.copy(); } else { next = null; } // FIX: @swen: here must be an error in the original implementation I just uncommented the next line because it seemed wrong // next = nextElement; }
/// <summary> /// Fires the action pattern. /// /// This method fires the current action / sense / sense-act or /// competence of the pattern. In case of firing an action / sense /// / sense-act, the method points to the next element in the /// pattern and returns FireResult(True, None) if the current /// action / sense / sense-act was successful (i.e. evaluated to /// True) and not the last action in the sequence, in which case /// it returns FireResult(False, None) and resets the action /// pattern. /// /// If the current element is a competence, then competence is /// returned as the next element by returning /// FireResult(True, competence), and the action pattern is /// reset. /// </summary> /// <returns>The result of firing the action pattern.</returns> public override FireResult fire() { log.Debug("Fired"); CopiableElement element = elements[elementIdx]; if (element is POSHAction || element is POSHSense) { bool result; if (element is POSHAction) { result = ((POSHAction)element).fire(); } else { result = ((POSHSense)element).fire(); } if (!result) { log.Debug(string.Format("Action/Sense {0} failed", element.getName())); elementIdx = 0; return(new FireResult(false, null)); } // check if we've just fired the last action elementIdx += 1; if (elementIdx >= elements.Count) { elementIdx = 0; return(new FireResult(false, null)); } return(new FireResult(true, null)); } else if (elements[elementIdx] is Competence) { // we have a competence elementIdx = 0; return(new FireResult(true, element)); } return(null); }
/// <summary> /// Fires the drive element. /// /// This method fires the current drive element and always /// returns None. It uses the slip-stack architecture to determine /// the element to fire in the next step. /// </summary> /// <returns>The result returned is null.</returns> public override FireResult fire() { FireResult result; log.Debug("Fired"); // if our element is an action, we just fire it and do // nothing afterwards. That's because we can only have an action // as an element, if it is the drive element's root element. // Hence, we didn't descend in the plan tree and can keep // the same element. if (element is POSHAction || element.GetType().IsSubclassOf(typeof(POSHAction))) { ((POSHAction)element).fire(); element = root; return(null); } // the element is a competence or an action pattern result = ((ElementCollection)element).fire(); if (result.continueExecution()) { // if we have a new next element, store it as the next // element to execute CopiableElement next = result.nextElement(); if (next is CopiableElement) { element = next; } } else { // we were told not to continue the execution -> back to root // We must not call reset() here, as that would also reset // the firing frequency of the element. element = root; } return(null); }