Changeset 950


Ignore:
Timestamp:
02/12/2011 05:24:08 PM (10 years ago)
Author:
joao.dias
Message:
 
Location:
AgentMind/branches/FAtiMA-Modular
Files:
26 edited

Legend:

Unmodified
Added
Removed
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/main/java/FAtiMA/advancedMemoryComponent/ActionsLoaderHandler.java

    r889 r950  
    5959        { 
    6060                _sac = SACondition.ParseSA(attributes); 
    61                 operator = _am.getDeliberativeLayer().getEmotionalPlanner().GetStep(_operatorKey); 
     61                operator =  
     62                 
     63                _am.getActionLibrary().getAction(_operatorKey); 
    6264   
    6365                _sac.MakeGround(_self); 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/main/java/FAtiMA/advancedMemoryComponent/AdvancedMemoryComponent.java

    r929 r950  
    4545import FAtiMA.Core.componentTypes.IAppraisalDerivationComponent; 
    4646import FAtiMA.Core.componentTypes.IProcessExternalRequestComponent; 
     47import FAtiMA.Core.componentTypes.IAppraisalDerivationComponent; 
     48import FAtiMA.Core.componentTypes.IProcessExternalRequestComponent; 
    4749import FAtiMA.Core.emotionalState.AppraisalFrame; 
    4850import FAtiMA.Core.memory.Memory; 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.EmotionalIntelligence/src/FAtiMA/emotionalIntelligence/EmotionalConditionsLoaderHandler.java

    r805 r950  
    3535                        ee = EmotionalEpisodeCondition.ParseEmotionalEpisodeCondition(attributes); 
    3636                        ee.MakeGround(_self); 
    37                         g = _aM.getDeliberativeLayer().getGoalLibrary().GetGoal(Name.ParseName(_currentGoalKey)); 
     37                        g = _aM.getGoalLibrary().GetGoal(Name.ParseName(_currentGoalKey)); 
    3838                        g.AddCondition(_conditionType, ee); 
    3939                } 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.EmotionalIntelligence/src/FAtiMA/emotionalIntelligence/EmotionalIntelligence.java

    r929 r950  
    1010import FAtiMA.Core.Display.AgentDisplayPanel; 
    1111import FAtiMA.Core.componentTypes.IComponent; 
    12 import FAtiMA.Core.deliberativeLayer.EmotionalPlanner; 
    1312import FAtiMA.Core.deliberativeLayer.plan.Step; 
    1413import FAtiMA.Core.reactiveLayer.Action; 
     
    3534        @Override 
    3635        public void initialize(AgentModel am) { 
    37                  
    38                 EmotionalPlanner planner = am.getDeliberativeLayer().getEmotionalPlanner(); 
    39                  
     36 
    4037                ArrayList<Step> occRules = OCCAppraisalRules.GenerateOCCAppraisalRules(am); 
    4138                for(Step s : occRules) 
    4239                { 
    43                         planner.AddOperator(s); 
     40                        am.getActionLibrary().addAction(s); 
    4441                } 
    4542                 
    4643                for(Action at: am.getReactiveLayer().getActionTendencies().getActions()) 
    4744                { 
    48                         planner.AddOperator(ActionTendencyOperatorFactory.CreateATOperator(am, at)); 
     45                        am.getActionLibrary().addAction(ActionTendencyOperatorFactory.CreateATOperator(am, at)); 
    4946                } 
    5047                 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.MotivationalSystem/src/FAtiMA/motivationalSystem/ActionEffectsOnDrives.java

    r772 r950  
    88 
    99public class ActionEffectsOnDrives implements Serializable{ 
     10         
     11        /** 
     12         *  
     13         */ 
     14        private static final long serialVersionUID = 1L; 
     15         
    1016         
    1117        private Name _actionName; 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.MotivationalSystem/src/FAtiMA/motivationalSystem/MotivationalComponent.java

    r929 r950  
    2121import FAtiMA.Core.componentTypes.IComponent; 
    2222import FAtiMA.Core.componentTypes.IModelOfOtherComponent; 
     23import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
    2324import FAtiMA.Core.deliberativeLayer.IActionFailureStrategy; 
    2425import FAtiMA.Core.deliberativeLayer.IExpectedUtilityStrategy; 
     
    271272         
    272273        public float getExpectedUtility(AgentModel am, ActivePursuitGoal g) 
    273         {                
    274                 float utility = am.getDeliberativeLayer().getUtilityStrategy().getUtility(am, g); 
    275                 float probability = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, g); 
     274        { 
     275                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     276                float utility = dp.getUtilityStrategy().getUtility(am, g); 
     277                float probability = dp.getProbabilityStrategy().getProbability(am, g); 
    276278                 
    277279                float EU = utility * probability * (1 + g.GetGoalUrgency()); 
     
    284286        public float getExpectedUtility(AgentModel am, Intention i) 
    285287        { 
    286                 float utility = am.getDeliberativeLayer().getUtilityStrategy().getUtility(am, i.getGoal()); 
    287                 float probability = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, i); 
     288                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     289                 
     290                float utility = dp.getUtilityStrategy().getUtility(am, i.getGoal()); 
     291                float probability = dp.getProbabilityStrategy().getProbability(am, i); 
    288292                 
    289293                float EU = utility * probability * (1 + i.getGoal().GetGoalUrgency()); 
     
    460464        @Override 
    461465        public void initialize(AgentModel am) { 
    462                 am.getDeliberativeLayer().setExpectedUtilityStrategy(this); 
    463                 am.getDeliberativeLayer().setProbabilityStrategy(this); 
    464                 am.getDeliberativeLayer().setUtilityStrategy(this); 
    465                 am.getDeliberativeLayer().addActionFailureStrategy(this); 
    466                 am.getDeliberativeLayer().addGoalFailureStrategy(this); 
    467                 am.getDeliberativeLayer().addGoalSuccessStrategy(this); 
     466                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     467                 
     468                dp.setExpectedUtilityStrategy(this); 
     469                dp.setProbabilityStrategy(this); 
     470                dp.setUtilityStrategy(this); 
     471                dp.addActionFailureStrategy(this); 
     472                dp.addGoalFailureStrategy(this); 
     473                dp.addGoalSuccessStrategy(this); 
    468474                LoadNeeds(am); 
    469475        } 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.SocialRelations/src/FAtiMA/socialRelations/RelationsLoaderHandler.java

    r801 r950  
    6262                        lc = LikeCondition.ParseSocialCondition(attributes); 
    6363                        lc.MakeGround(_self); 
    64                         g = _aM.getDeliberativeLayer().getGoalLibrary().GetGoal(Name.ParseName(_currentGoalKey)); 
     64                        g = _aM.getGoalLibrary().GetGoal(Name.ParseName(_currentGoalKey)); 
    6565                        g.AddCondition(_conditionType, lc); 
    6666                } 
     
    7878                l.MakeGround(_self); 
    7979 
    80                 Step action = _aM.getDeliberativeLayer().getEmotionalPlanner().GetStep(_currentActionKey); 
     80                Step action = _aM.getActionLibrary().getAction(_currentActionKey); 
    8181                if(_precondition) 
    8282                        action.AddPrecondition(l); 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.ToM/src/FAtiMA/ToM/ModelOfOther.java

    r929 r950  
    66import java.util.HashMap; 
    77 
     8import FAtiMA.Core.ActionLibrary; 
    89import FAtiMA.Core.AgentCore; 
    910import FAtiMA.Core.AgentModel; 
     
    1415import FAtiMA.Core.componentTypes.IProcessEmotionComponent; 
    1516import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
     17import FAtiMA.Core.deliberativeLayer.goals.GoalLibrary; 
    1618import FAtiMA.Core.emotionalState.ActiveEmotion; 
    1719import FAtiMA.Core.emotionalState.AppraisalFrame; 
     
    190192                return _components.values(); 
    191193        } 
    192  
    193         @Override 
    194         public DeliberativeProcess getDeliberativeLayer() { 
    195                 return _deliberativeProcess; 
     194         
     195        public GoalLibrary getGoalLibrary() 
     196        { 
     197                return null; 
     198        } 
     199         
     200        public ActionLibrary getActionLibrary() 
     201        { 
     202                return null; 
    196203        } 
    197204 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.ToM/src/FAtiMA/ToM/ToMComponent.java

    r929 r950  
    1414import FAtiMA.Core.componentTypes.IComponent; 
    1515import FAtiMA.Core.componentTypes.IModelOfOtherComponent; 
     16import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
    1617import FAtiMA.Core.deliberativeLayer.IGetUtilityForOthers; 
    1718import FAtiMA.Core.deliberativeLayer.goals.ActivePursuitGoal; 
     
    7071        @Override 
    7172        public void initialize(AgentModel am) { 
     73                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
    7274                am.setModelStrategy(this); 
    73                 am.getDeliberativeLayer().setDetectThreatStrategy(new DetectThreatStrategy()); 
    74                 am.getDeliberativeLayer().setUtilityForOthersStrategy(this); 
     75                dp.setDetectThreatStrategy(new DetectThreatStrategy()); 
     76                dp.setUtilityForOthersStrategy(this); 
    7577        } 
    7678         
     
    242244        @Override 
    243245        public float getUtilityForOthers(AgentModel am, ActivePursuitGoal g) { 
     246                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
    244247                 
    245248                float utility = 0; 
     
    247250                for(ModelOfOther m : _ToM.values()) 
    248251                { 
    249                         utility+= m.getDeliberativeLayer().getUtilityStrategy().getUtility(m, g); 
     252                        utility+= dp.getUtilityStrategy().getUtility(m, g); 
    250253                } 
    251254                 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.culture/src/FAtiMA/culture/CulturalDimensionsComponent.java

    r937 r950  
    1515import FAtiMA.Core.componentTypes.IAppraisalDerivationComponent; 
    1616import FAtiMA.Core.conditions.Condition; 
     17import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
    1718import FAtiMA.Core.deliberativeLayer.IExpectedUtilityStrategy; 
    1819import FAtiMA.Core.deliberativeLayer.IGetUtilityForOthers; 
     
    5758        @Override 
    5859        public void initialize(AgentModel aM){ 
     60                DeliberativeProcess dp = (DeliberativeProcess) aM.getComponent(DeliberativeProcess.NAME); 
    5961                this.loadCulture(aM); 
    60                 aM.getDeliberativeLayer().AddOptionsStrategy(this); 
    61                 aM.getDeliberativeLayer().setExpectedUtilityStrategy(this); 
     62                dp.addOptionsStrategy(this); 
     63                dp.setExpectedUtilityStrategy(this); 
    6264                aM.getRemoteAgent().setProcessActionStrategy(new CultureProcessActionStrategy()); 
    6365        } 
     
    111113                Ritual r2, r3; 
    112114                String ritualName; 
     115                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
    113116                 
    114117                //this section detects if a ritual has started with another agent's action 
     
    138141                                                                ritualName = r3.getNameWithCharactersOrdered(); 
    139142                                                                r3.setUrgency(2); 
    140                                                                 if(!_ritualOptions.containsKey(ritualName) && !am.getDeliberativeLayer().ContainsIntention(r3)) 
     143                                                                if(!_ritualOptions.containsKey(ritualName) && !dp.containsIntention(r3)) 
    141144                                                                { 
    142145                                                                        AgentLogger.GetInstance().logAndPrint("Reactive Activation of a Ritual:" + r3.getName()); 
     
    159162         
    160163        private void loadCulture(AgentModel aM){ 
     164                 
     165                DeliberativeProcess dp = (DeliberativeProcess) aM.getComponent(DeliberativeProcess.NAME); 
    161166 
    162167                AgentLogger.GetInstance().log("LOADING Culture: " + this.cultureFile); 
     
    171176                        for(Ritual r : cultureLoader.GetRituals(aM)){ 
    172177                                this._rituals.add(r); 
    173                                 aM.getDeliberativeLayer().AddGoal(r); 
     178                                dp.addGoal(r); 
    174179                        } 
    175180 
     
    276281        public Collection<? extends ActivePursuitGoal> options(AgentModel am) { 
    277282                 
     283                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     284                 
    278285                Iterator<Ritual> it = _ritualOptions.values().iterator(); 
    279286                Ritual r; 
     
    282289                { 
    283290                        r = it.next(); 
    284                         if(am.getDeliberativeLayer().ContainsIntention(r)) 
     291                        if(dp.containsIntention(r)) 
    285292                        { 
    286293                                it.remove(); 
     
    294301        private float culturalEU(AgentModel am, ActivePursuitGoal g, float probability) 
    295302        { 
    296                 IUtilityStrategy str =  am.getDeliberativeLayer().getUtilityStrategy(); 
     303                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     304                 
     305                IUtilityStrategy str =  dp.getUtilityStrategy(); 
    297306                 
    298307                float contributionToSelf = str.getUtility(am, g); 
    299308                 
    300                 IGetUtilityForOthers ostrat = am.getDeliberativeLayer().getUtilityForOthersStrategy(); 
     309                IGetUtilityForOthers ostrat = dp.getUtilityForOthersStrategy(); 
    301310                 
    302311                float contributionOthers = ostrat.getUtilityForOthers(am, g); 
     
    314323        @Override 
    315324        public float getExpectedUtility(AgentModel am, ActivePursuitGoal g) { 
    316                  
    317                 float probability = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, g); 
     325                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     326                 
     327                float probability = dp.getProbabilityStrategy().getProbability(am, g); 
    318328                return culturalEU(am,g,probability); 
    319329        } 
     
    322332        public float getExpectedUtility(AgentModel am, Intention i) { 
    323333                 
    324                 float probability = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, i); 
     334                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME);  
     335                 
     336                float probability = dp.getProbabilityStrategy().getProbability(am, i); 
    325337                 
    326338                return culturalEU(am,i.getGoal(),probability); 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.culture/src/FAtiMA/culture/CultureLoaderHandler.java

    r878 r950  
    7979                _rituals = new ArrayList<Ritual>(); 
    8080                _self = new Substitution(new Symbol("[SELF]"), new Symbol(FAtiMA.Core.util.Constants.SELF)); 
    81                 _reactiveLayer = aM.getReactiveLayer();  
    82                 _deliberativeLayer = aM.getDeliberativeLayer(); 
     81                _reactiveLayer = (ReactiveProcess) aM.getComponent(ReactiveProcess.NAME);  
     82                _deliberativeLayer = (DeliberativeProcess) aM.getComponent(DeliberativeProcess.NAME); 
    8383                _am = aM; 
    8484                _culturalComponent = cDM; 
     
    172172                if(_beforeRituals){ 
    173173                        String goalName = attributes.getValue("name");   
    174                     _deliberativeLayer.AddGoal(_am, goalName);   
     174                        _deliberativeLayer.addGoal(_am, goalName);   
    175175                } 
    176176    } 
     
    216216                stepName = Name.ParseName(attributes.getValue("name")); 
    217217                role = new Symbol(attributes.getValue("role")); 
    218                 _ritual.AddStep(stepName, role); 
     218                _ritual.AddStep(_am, stepName, role); 
    219219        } 
    220220 
     
    266266                        _ritual.AddCondition(_conditionType, cond); 
    267267                }else if (_currentGoalKey != null){ 
    268                         Goal g = _deliberativeLayer.getGoalLibrary().GetGoal(Name.ParseName(_currentGoalKey)); 
     268                        Goal g = _am.getGoalLibrary().GetGoal(Name.ParseName(_currentGoalKey)); 
    269269                        g.AddCondition(_conditionType, cond); 
    270270                } 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.culture/src/FAtiMA/culture/Ritual.java

    r733 r950  
    3636import java.util.ListIterator; 
    3737 
    38 import FAtiMA.Core.ActionLibrary; 
    3938import FAtiMA.Core.AgentModel; 
    4039import FAtiMA.Core.conditions.Condition; 
     40import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
    4141import FAtiMA.Core.deliberativeLayer.goals.ActivePursuitGoal; 
    4242import FAtiMA.Core.deliberativeLayer.plan.CausalLink; 
     
    8484        } 
    8585         
    86         public void AddStep(Name actionName, Name role) 
     86        public void AddStep(AgentModel am, Name actionName, Name role) 
    8787        { 
    8888                ArrayList<Substitution> subst; 
    89                 Step action = ActionLibrary.GetInstance().GetAction(_steps.size(), actionName); 
     89                Step action =  am.getActionLibrary().getAction(_steps.size(), actionName); 
    9090                if(action != null) 
    9191                { 
     
    164164        public void BuildPlan(AgentModel am) 
    165165        { 
     166                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     167                 
    166168                Step s; 
    167169                OrderingConstraint o; 
    168                 _plan = new Plan(new ArrayList<ProtectedCondition>(),am.getDeliberativeLayer().getDetectThreatStrategy(),_successConditions); 
     170                _plan = new Plan(new ArrayList<ProtectedCondition>(),dp.getDetectThreatStrategy(),_successConditions); 
    169171                 
    170172                for(int i=0; i < _steps.size(); i++) 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/ActionLibrary.java

    r667 r950  
    3131 
    3232import java.io.File; 
    33 import java.io.FileInputStream; 
    34 import java.io.FileOutputStream; 
    35 import java.io.ObjectInputStream; 
    36 import java.io.ObjectOutputStream; 
    3733import java.io.Serializable; 
    3834import java.util.ArrayList; 
     
    4440import FAtiMA.Core.deliberativeLayer.plan.Step; 
    4541import FAtiMA.Core.exceptions.ActionsParsingException; 
     42import FAtiMA.Core.exceptions.UnknownSpeechActException; 
     43import FAtiMA.Core.exceptions.UnspecifiedVariableException; 
    4644import FAtiMA.Core.util.AgentLogger; 
    4745import FAtiMA.Core.util.parsers.ActionsLoaderHandler; 
     
    5351 * @author João Dias 
    5452 * Class that stores the STRIPS definition of the domain actions 
    55  * You cannot create an ActionLibrary since there is one and only instance  
    56  * for the agent. If you want to access it use AgentLibrary.GetInstance() method. 
    5753 */ 
    5854public class ActionLibrary implements Serializable { 
    5955 
    60         private static final long serialVersionUID = 1L; 
     56        private static final long serialVersionUID = 1L;         
    6157         
    62         /** 
    63          * Singleton pattern  
    64          */ 
    65         private static ActionLibrary _actionLibraryInstance = null; 
     58        private ArrayList<Step> _actions; 
    6659         
    67         /** 
    68          * Gets a the library with all actions specified in a STRIPS-like fashion 
    69          *  
    70          * @return an ActionLibrary 
    71          */ 
    72         public static ActionLibrary GetInstance() 
     60 
     61        public ActionLibrary() 
    7362        { 
    74                 if(_actionLibraryInstance == null) 
    75                 { 
    76                         _actionLibraryInstance = new ActionLibrary(); 
    77                 } 
    78                 return _actionLibraryInstance; 
     63                _actions = new ArrayList<Step>(); 
     64        } 
     65         
     66        public void addAction(Step action) 
     67        { 
     68                _actions.add(action); 
    7969        } 
    8070         
    8171        /** 
    82          * Saves the state of the current ActionLibrary to a file, 
    83          * so that it can be later restored from file 
    84          * @param fileName - the name of the file where we must write 
    85          *                           the state of the timer 
     72         * Checks the integrity of the Planner operators/Steps/actions. 
     73         * For instance it checks if a operator references a SpeechAct not  
     74         * defined, or if it uses a unbound variable (in effects or preconditions) 
     75         * not used in the operator's name  
     76         * @param val - the IntegrityValidator used to detect problems 
     77         * @throws UnspecifiedVariableException - thrown when the operator uses a unbound 
     78         *                                                                                variable in the effects or preconditions 
     79         *                                                                            without using the same variable in the  
     80         *                                                                            step's name 
     81         * @throws UnknownSpeechActException - thrown when the operator references a  
     82         *                                                                         SpeechAct not defined 
    8683         */ 
    87         public static void SaveState(String fileName) 
     84        public void checkIntegrity(IntegrityValidator val) throws UnspecifiedVariableException, UnknownSpeechActException { 
     85            ListIterator<Step> li = _actions.listIterator(); 
     86             
     87            while(li.hasNext()) { 
     88                 li.next().CheckIntegrity(val); 
     89            } 
     90        } 
     91         
     92        public Step getAction(int id, Name actionName) 
    8893        { 
    89                 try  
     94                Step s; 
     95                ArrayList<Substitution> subst; 
     96                 
     97                for(ListIterator<Step> li = _actions.listIterator(); li.hasNext();) 
    9098                { 
    91                         FileOutputStream out = new FileOutputStream(fileName); 
    92                 ObjectOutputStream s = new ObjectOutputStream(out); 
    93                  
    94                 s.writeObject(_actionLibraryInstance); 
    95                 s.flush(); 
    96                 s.close(); 
    97                 out.close(); 
     99                        s = (Step) li.next(); 
     100                        s = (Step)s.clone(); 
     101                        s.ReplaceUnboundVariables(id); 
     102                         
     103                        subst = Unifier.Unify(s.getName(), actionName); 
     104                        if(subst != null) 
     105                        { 
     106                                s = (Step) s.clone(); 
     107                                s.MakeGround(subst); 
     108                                return s; 
     109                        } 
    98110                } 
    99                 catch(Exception e) 
    100                 { 
    101                         AgentLogger.GetInstance().logAndPrint("Exception: " + e); 
    102                         e.printStackTrace(); 
    103                 } 
     111                 
     112                return null; 
    104113        } 
    105114         
    106115        /** 
    107          * Loads a specific state of the ActionLibrary from a previously 
    108          * saved file 
    109          * @param fileName - the name of the file that contains the stored 
    110          *                                       timer 
     116         * Gets the operator that corresponds to the given name 
     117         * @param name - the name of the step to get 
     118         * @return the searched step if it is found, null otherwise 
    111119         */ 
    112         public static void LoadState(String fileName) 
     120        public Step getAction(String name) { 
     121                 
     122                for(Step s : _actions) 
     123                { 
     124                        if(s.getName().toString().equals(name)) 
     125                        { 
     126                                return s; 
     127                        } 
     128                } 
     129                 
     130                return null; 
     131        } 
     132         
     133        public ArrayList<Step> getActions() 
    113134        { 
    114                 try 
    115                 { 
    116                         FileInputStream in = new FileInputStream(fileName); 
    117                 ObjectInputStream s = new ObjectInputStream(in); 
    118                 _actionLibraryInstance = (ActionLibrary) s.readObject(); 
    119                  
    120                 s.close(); 
    121                 in.close(); 
    122                 } 
    123                 catch (Exception e) 
    124                 { 
    125                         e.printStackTrace(); 
    126                 } 
    127         } 
    128  
    129         private ArrayList<Step> _actions; 
    130          
    131         /** 
    132          * Creates a new timer for the Agent's simulation 
    133          * 
    134          */ 
    135         private ActionLibrary() 
    136         { 
    137                 _actions = new ArrayList<Step>(); 
     135                return _actions; 
    138136        } 
    139137         
     
    159157                }        
    160158        } 
    161          
    162         public ArrayList<Step> GetActions() 
    163         { 
    164                 return _actions; 
    165         } 
    166          
    167         public Step GetAction(int id, Name actionName) 
    168         { 
    169                 Step s; 
    170                 ArrayList<Substitution> subst; 
    171                  
    172                 for(ListIterator<Step> li = _actions.listIterator(); li.hasNext();) 
    173                 { 
    174                         s = (Step) li.next(); 
    175                         s = (Step)s.clone(); 
    176                         s.ReplaceUnboundVariables(id); 
    177                          
    178                         subst = Unifier.Unify(s.getName(), actionName); 
    179                         if(subst != null) 
    180                         { 
    181                                 s = (Step) s.clone(); 
    182                                 s.MakeGround(subst); 
    183                                 return s; 
    184                         } 
    185                 } 
    186                  
    187                 return null; 
    188         } 
    189159} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/AgentCore.java

    r928 r950  
    3636import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
    3737import FAtiMA.Core.deliberativeLayer.EmotionalPlanner; 
     38import FAtiMA.Core.deliberativeLayer.goals.Goal; 
    3839import FAtiMA.Core.deliberativeLayer.goals.GoalLibrary; 
    3940import FAtiMA.Core.emotionalState.ActiveEmotion; 
     
    7576        public static final Name ACTION_CONTEXT = Name.ParseName("ActionContext()"); 
    7677 
     78        //components 
    7779        protected HashMap<String, IComponent> _generalComponents; 
    7880        protected ArrayList<IProcessEmotionComponent> _processEmotionComponents; 
     
    8486        protected ArrayList<IAppraisalDerivationComponent> _appraisalComponents; 
    8587         
     88        //Data structures 
    8689        protected EmotionalState _emotionalState; 
    8790        protected Memory _memory; 
     91        protected GoalLibrary _goalLibrary; 
     92        protected ActionLibrary _actionLibrary; 
     93         
    8894        protected boolean _shutdown; 
    8995        protected DeliberativeProcess _deliberativeLayer; 
     
    122128                _perceivedEvents = new ArrayList<Event>(); 
    123129                _saveDirectory = ""; 
     130                 
    124131                _emotionalState = new EmotionalState(); 
    125132                _memory = new Memory(); 
     
    128135                _memoryWriter = new MemoryWriter(_memory); 
    129136                _strat = this; 
     137                _actionLibrary = new ActionLibrary(); 
    130138                 
    131139                _generalComponents = new HashMap<String,IComponent>(); 
     
    184192                                 
    185193                                // Load Plan Operators 
    186                                 ActionLibrary.GetInstance().LoadActionsFile(ConfigurationManager.getActionsFile(), this); 
    187                                 EmotionalPlanner planner = new EmotionalPlanner(ActionLibrary.GetInstance().GetActions()); 
     194                                _actionLibrary.LoadActionsFile(ConfigurationManager.getActionsFile(), this); 
     195                                EmotionalPlanner planner = new EmotionalPlanner(); 
    188196         
    189197                                // Load GoalLibrary 
    190                                 GoalLibrary goalLibrary = new GoalLibrary(ConfigurationManager.getGoalsFile()); 
     198                                _goalLibrary = new GoalLibrary(ConfigurationManager.getGoalsFile()); 
    191199         
    192200                                //For efficiency reasons these two are not real processes 
     
    194202                                addComponent(_reactiveLayer); 
    195203         
    196                                 _deliberativeLayer = new DeliberativeProcess(goalLibrary,planner); 
     204                                _deliberativeLayer = new DeliberativeProcess(planner); 
    197205                                addComponent(_deliberativeLayer); 
    198206                                 
     
    357365                return this._processExternalRequestComponents; 
    358366        } 
     367         
     368        public ActionLibrary getActionLibrary() 
     369        { 
     370                return _actionLibrary; 
     371        } 
    359372 
    360373        /*public void RemoveComponent(IComponent c) 
     
    366379        public void AppraiseSelfActionFailed(Event e) 
    367380        { 
    368                 _deliberativeLayer.AppraiseSelfActionFailed(e); 
     381                _deliberativeLayer.appraiseSelfActionFailed(e); 
    369382        } 
    370383 
     
    405418        } 
    406419         
     420        public GoalLibrary getGoalLibrary() 
     421        { 
     422                return _goalLibrary; 
     423        } 
     424         
    407425        /** 
    408426         * Gets the name of the agent 
     
    430448                _strat = strat; 
    431449        } 
     450         
     451        public void EnforceCopingStrategy(AgentModel am, String coping) 
     452        { 
     453                Goal g; 
     454                coping = coping.toLowerCase(); 
     455                for(ListIterator<Goal> li = _goalLibrary.GetGoals();li.hasNext();) 
     456                { 
     457                        g = (Goal) li.next(); 
     458                        if(g.getName().toString().toLowerCase().startsWith(coping) 
     459                                        || (coping.equals("standup") && g.getName().toString().startsWith("ReplyNegatively"))) 
     460                        { 
     461                                AgentLogger.GetInstance().logAndPrint(""); 
     462                                AgentLogger.GetInstance().logAndPrint("Enforcing coping strategy: " + g.getName()); 
     463                                AgentLogger.GetInstance().logAndPrint(""); 
     464                                g.IncreaseImportanceOfFailure(am, 2); 
     465                                g.IncreaseImportanceOfSuccess(am, 2); 
     466                        } 
     467                } 
     468        } 
    432469 
    433470 
     
    444481                this._emotionalState = (EmotionalState) s.readObject(); 
    445482                this._memory = (Memory) s.readObject(); 
     483                this._goalLibrary = (GoalLibrary) s.readObject(); 
     484                this._actionLibrary = (ActionLibrary) s.readObject(); 
    446485                //this._dialogManager = (DialogManager) s.readObject(); 
    447486                this._role = (String) s.readObject(); 
     
    483522 
    484523                AgentSimulationTime.LoadState(fileName+"-Timer.dat"); 
    485                 ActionLibrary.LoadState(fileName+"-ActionLibrary.dat"); 
    486524 
    487525                //_remoteAgent.LoadState(fileName+"-RemoteAgent.dat"); 
     
    507545                if(agentPlatform == AgentPlatform.WORLDSIM){ 
    508546                        ListIterator<String> lt = goalList.listIterator(); 
    509                         String goal; 
     547                        String goalDescription; 
    510548                        String goalName; 
    511549                        StringTokenizer st; 
     
    513551                        float impOfFailure; 
    514552                        while(lt.hasNext()) { 
    515                                 goal = (String) lt.next(); 
    516                                 st = new StringTokenizer(goal, "|"); 
     553                                goalDescription = (String) lt.next(); 
     554                                st = new StringTokenizer(goalDescription, "|"); 
    517555                                goalName = st.nextToken(); 
    518556                                impOfSuccess = Float.parseFloat(st.nextToken()); 
    519557                                impOfFailure = Float.parseFloat(st.nextToken()); 
    520558 
    521                                 _deliberativeLayer.AddGoal(this, goalName, impOfSuccess, impOfFailure);    
     559                                _deliberativeLayer.addGoal(this, goalName, impOfSuccess, impOfFailure);    
    522560                        }        
    523561                } 
     
    870908 
    871909                AgentSimulationTime.SaveState(fileName+"-Timer.dat"); 
    872                 ActionLibrary.SaveState(fileName+"-ActionLibrary.dat"); 
    873910                _remoteAgent.SaveState(fileName+"-RemoteAgent.dat"); 
    874911 
     
    882919                        s.writeObject(_emotionalState); 
    883920                        s.writeObject(_memory); 
     921                        s.writeObject(_goalLibrary); 
     922                        s.writeObject(_actionLibrary); 
    884923                        //s.writeObject(_dialogManager); 
    885924                        s.writeObject(_role); 
     
    9701009                        s.writeObject(_emotionalState); 
    9711010                        s.writeObject(_memory); 
     1011                        s.writeObject(_goalLibrary); 
     1012                        s.writeObject(_actionLibrary); 
    9721013                        //s.writeObject(_motivationalState); 
    9731014                        //s.writeObject(_dialogManager); 
     
    10311072                        this._emotionalState = (EmotionalState) s.readObject(); 
    10321073                        this._memory = (Memory) s.readObject(); 
     1074                        this._goalLibrary = (GoalLibrary) s.readObject(); 
     1075                        this._actionLibrary = (ActionLibrary) s.readObject(); 
    10331076                        //this._dialogManager = (DialogManager) s.readObject(); 
    10341077                        //this._role = (String) s.readObject(); 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/AgentModel.java

    r926 r950  
    22 
    33import FAtiMA.Core.componentTypes.IComponent; 
    4 import FAtiMA.Core.deliberativeLayer.DeliberativeProcess; 
     4import FAtiMA.Core.deliberativeLayer.goals.GoalLibrary; 
    55import FAtiMA.Core.emotionalState.AppraisalFrame; 
    66import FAtiMA.Core.emotionalState.EmotionalState; 
     
    1212public interface AgentModel { 
    1313         
     14        public ActionLibrary getActionLibrary(); 
     15         
     16        public IComponent getComponent(String name); 
     17         
     18        public EmotionalState getEmotionalState();  
     19         
     20        public GoalLibrary getGoalLibrary(); 
     21         
     22        public Memory getMemory(); 
     23         
     24        //public DeliberativeProcess getDeliberativeLayer(); 
     25         
     26        public AgentModel getModelToTest(Symbol ToM); 
     27         
    1428        public String getName(); 
    15          
    16         public EmotionalState getEmotionalState(); 
    17          
    18         public Memory getMemory();  
    19          
    20         public DeliberativeProcess getDeliberativeLayer(); 
    2129         
    2230        public ReactiveProcess getReactiveLayer(); 
    2331         
    24         public AgentModel getModelToTest(Symbol ToM); 
     32        public RemoteAgent getRemoteAgent(); 
     33         
     34        public boolean isSelf(); 
    2535         
    2636        public void setModelStrategy(IGetModelStrategy strat); 
    27          
    28         public RemoteAgent getRemoteAgent(); 
    29          
    30         public IComponent getComponent(String name); 
    31          
    32         public boolean isSelf(); 
    3337         
    3438        public void updateEmotions(AppraisalFrame af); 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/AgentSimulationTime.java

    r667 r950  
    209209        public void Tick() 
    210210        { 
     211                long elapsedSimulationTime; 
    211212                long currentTime = System.currentTimeMillis(); 
    212213                long elapsedRealTime = currentTime - this._lastUpdateTime; 
     
    215216                if(this._running) 
    216217                { 
    217                         this._simulationTime += elapsedRealTime * this._timeMultiplier; 
    218                 } 
    219         } 
    220          
    221         /** 
    222          * Advances the agent's simulation time. Very usefull if you 
     218                        elapsedSimulationTime = (long) (elapsedRealTime * this._timeMultiplier); 
     219                        this._simulationTime += elapsedSimulationTime; 
     220                } 
     221        } 
     222         
     223        /** 
     224         * Advances the agent's simulation time. Very useful if you 
    223225         * want to skip time.  
    224226         * @param seconds - the number of seconds you want to advance 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/Display/GoalsPanel.java

    r667 r950  
    100100        DeliberativeProcess deliberative = ag.getDeliberativeLayer(); 
    101101         
    102         if(_goalDisplays.size() != deliberative.GetGoals().size()) { 
     102        if(_goalDisplays.size() != deliberative.getGoals().size()) { 
    103103                update = true; 
    104104                _goals.removeAll(); 
    105105                _goalDisplays.clear(); 
    106106                 
    107                 Iterator<Goal> it = deliberative.GetGoals().iterator(); 
     107                Iterator<Goal> it = deliberative.getGoals().iterator(); 
    108108                GoalDisplay gDisplay; 
    109109                Goal g; 
     
    117117        } 
    118118         
    119         if(_intentionDisplays.keySet().equals(deliberative.GetIntentionKeysSet())) { 
     119        if(_intentionDisplays.keySet().equals(deliberative.getIntentionKeysSet())) { 
    120120            //in this case, we just have to update the values for the intensity of emotions 
    121121            //since the emotions displayed in the previous update are the same emotions 
    122122            //in the current update 
    123              Iterator<Intention> it = deliberative.GetIntentionsIterator(); 
     123             Iterator<Intention> it = deliberative.getIntentionsIterator(); 
    124124             IntentionDisplay iDisplay; 
    125125             Intention i; 
     
    136136            _intentionDisplays.clear(); 
    137137             
    138             Iterator<Intention> it = deliberative.GetIntentionsIterator(); 
     138            Iterator<Intention> it = deliberative.getIntentionsIterator(); 
    139139            IntentionDisplay iDisplay; 
    140140            Intention i; 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/deliberativeLayer/DeliberativeProcess.java

    r926 r950  
    135135import FAtiMA.Core.deliberativeLayer.goals.ActivePursuitGoal; 
    136136import FAtiMA.Core.deliberativeLayer.goals.Goal; 
    137 import FAtiMA.Core.deliberativeLayer.goals.GoalLibrary; 
    138137import FAtiMA.Core.deliberativeLayer.goals.InterestGoal; 
    139138import FAtiMA.Core.deliberativeLayer.plan.Effect; 
     
    174173        private ArrayList<Goal> _goals; 
    175174         
    176         private GoalLibrary _goalLibrary; 
    177175        private EmotionalPlanner _planner; 
    178176        private ActionMonitor _actionMonitor; 
     
    202200         * @param planner - the EmotionalPlanner that will be used by the deliberative layer 
    203201         */ 
    204         public DeliberativeProcess(GoalLibrary goalLibrary,  EmotionalPlanner planner) { 
     202        public DeliberativeProcess(EmotionalPlanner planner) { 
    205203                _goals = new ArrayList<Goal>(); 
    206204         
    207                 _goalLibrary = goalLibrary; 
    208205                _planner = planner; 
    209206                _actionMonitor = null; 
     
    229226        } 
    230227         
    231         public void addGoalSuccessStrategy(IGoalSuccessStrategy strat) 
    232         { 
    233                 _goalSuccessStrategies.add(strat); 
    234         } 
    235          
    236         public void addGoalFailureStrategy(IGoalFailureStrategy strat) 
    237         { 
    238                 _goalFailureStrategies.add(strat); 
    239         } 
    240          
    241         public void addActionSuccessStrategy(IActionSuccessStrategy strat) 
    242         { 
    243                 _actionSuccessStrategies.add(strat); 
    244         } 
    245          
    246         public void addActionFailureStrategy(IActionFailureStrategy strat) 
    247         { 
    248                 _actionFailureStrategies.add(strat); 
    249         } 
    250          
    251         public void setUtilityForOthersStrategy(IGetUtilityForOthers strat) 
    252         { 
    253                 _UOthersStrategy = strat; 
    254         } 
    255          
    256         public void setDetectThreatStrategy(IDetectThreatStrategy strat) 
    257         { 
    258                 _isThreatStrat = strat; 
    259         } 
    260          
    261         public void setExpectedUtilityStrategy(IExpectedUtilityStrategy strategy) 
    262         { 
    263                 _EUStrategy = strategy; 
    264         } 
    265          
    266         public void setProbabilityStrategy(IProbabilityStrategy strategy) 
    267         { 
    268                 _PStrategy = strategy; 
    269         } 
    270          
    271         public void setUtilityStrategy(IUtilityStrategy strategy) 
    272         { 
    273                 _UStrategy = strategy; 
    274         } 
    275          
    276         public IExpectedUtilityStrategy getExpectedUtilityStrategy() 
    277         { 
    278                 return _EUStrategy; 
    279         } 
    280          
    281         public IGetUtilityForOthers getUtilityForOthersStrategy() 
    282         { 
    283                 return _UOthersStrategy; 
    284         } 
    285          
    286         public IProbabilityStrategy getProbabilityStrategy() 
    287         { 
    288                 return _PStrategy; 
    289         } 
    290          
    291         public IUtilityStrategy getUtilityStrategy() 
    292         { 
    293                 return _UStrategy; 
    294         } 
    295          
    296         public IDetectThreatStrategy getDetectThreatStrategy() 
    297         { 
    298                 return _isThreatStrat; 
    299         } 
    300          
    301         /** 
    302          * Adds a goal to the agent's Goal List 
    303          * @param goal - the goal to add 
    304          */ 
    305         public void AddGoal(Goal goal) { 
    306                 InterestGoal iGoal; 
    307                 ArrayList<Condition> protectionConstraints; 
    308                 ListIterator<Condition> li; 
    309                  
    310                 synchronized (this) { 
    311                         if(!_goals.contains(goal)) { 
    312                             _goals.add(goal); 
    313                             if (goal instanceof InterestGoal) { 
    314                                         iGoal = (InterestGoal) goal; 
    315                                         protectionConstraints = iGoal.getProtectionConstraints(); 
    316                                         if(protectionConstraints != null) 
    317                                         { 
    318                                                 li = protectionConstraints.listIterator(); 
    319                                                 while(li.hasNext()) 
    320                                                 { 
    321                                                         AddProtectionConstraint(new ProtectedCondition(iGoal, (Condition) li.next())); 
    322                                                 } 
    323                                         } 
    324                                 } 
    325                         } 
    326                 } 
    327         } 
    328          
    329         /** 
    330          * Adds a ProtectionConstraint to the DeliberativeLayer. The planner will detect 
    331          * when there are threats to these ProtectionConstraints and deal with them 
    332          * with emotion-focused coping strategies.  
    333          *  
    334          * @param cond - the ProtectedCondition to add 
    335          * @see ProtectedCondition 
    336          */ 
    337         public void AddProtectionConstraint(ProtectedCondition cond) { 
    338                 _protectionConstraints.add(cond); 
    339         } 
    340          
    341          
    342         /** 
    343          * Updates all the plans that the deliberative layer is currently working with, i.e., 
    344          * it updates all plans of all current active intentions 
    345          */ 
    346         public void CheckLinks(AgentModel am) { 
    347                 Iterator<Intention> it; 
    348                  
    349                 synchronized(this) 
    350                 { 
    351                         it = _intentions.values().iterator(); 
    352                         while (it.hasNext()) { 
    353                                 ((Intention) it.next()).CheckLinks(am); 
    354                         } 
    355                 } 
    356         } 
    357          
    358         public boolean ContainsIntention(ActivePursuitGoal goal) 
    359         { 
    360                 String goalName = goal.getNameWithCharactersOrdered(); 
    361                  
    362                 return _intentions.containsKey(goalName); 
    363                  
    364                  
    365                 /* 
    366                 while(it.hasNext()) 
    367                 { 
    368                         i = (Intention) it.next(); 
    369                         if (i.containsIntention(goalName)) return true; 
    370                 } 
    371                  
    372                 return false;*/ 
    373         } 
    374          
    375         /** 
    376          * Changes a Goal's Importance 
    377          * @param goalName - the name of the goal to change 
    378          * @param importance - the new value for the importance 
    379          * @param importanceType - the type of importance:  
    380          *                                                 the String "CIS" changes the importance of success 
    381          *                                                 the String "CIF" changes the importance of failure 
    382          */ 
    383         public void ChangeGoalImportance(AgentModel am, String goalName, float importance, String importanceType) { 
    384                 ListIterator<Goal> li; 
    385                  
    386                 synchronized (this) { 
    387                         li = _goals.listIterator(); 
    388                         Goal g; 
    389                          
    390                         while(li.hasNext()) { 
    391                                 g = (Goal) li.next(); 
    392                                 if(goalName.equals(g.getName().toString())) { 
    393                                         if(importanceType.equals("CIS")) { 
    394                                                 g.SetImportanceOfSuccess(am, importance); 
    395                                         } 
    396                                         else { 
    397                                                 g.SetImportanceOfFailure(am, importance); 
    398                                         } 
    399                                         break; 
    400                                 } 
    401                         }        
    402                 } 
    403         } 
    404          
    405         /** 
    406          * Removes a given goal from the agent's goal list 
    407          * @param goalName - the name of the goal to remove 
    408          */ 
    409         public void RemoveGoal(String goalName) { 
    410                 Goal g; 
    411                  
    412                 synchronized (this) 
    413                 { 
    414                         for(int i=0; i < _goals.size(); i++) { 
    415                                 g = (Goal) _goals.get(i); 
    416                                 if(goalName.equals(g.getName().toString())) { 
    417                                         _goals.remove(i); 
    418                                         break; 
    419                                 } 
    420                         } 
    421                 } 
    422         } 
    423          
    424         /** 
    425          * Removes all the agent's goals 
    426          * 
    427          */ 
    428         public void RemoveAllGoals() { 
    429                  
    430                 synchronized (this) 
    431                 { 
    432                         _goals.clear(); 
    433                         _options.clear(); 
    434                         _intentions.clear(); 
    435                 } 
    436         } 
    437          
    438         /** 
    439          * Adds a goal to the agent's Goal List 
    440          * @param goalName - the name of the Goal 
    441          * @param importanceOfSuccess - the goal's importance of success 
    442          * @param importanceOfFailure - the goal's importance of failure 
    443          * @throws UnknownGoalException - thrown if the goal is not specified 
    444          *                                                        in the GoalLibrary file. You can only add 
    445          *                                                                goals defined in the GoalLibrary. 
    446          */ 
    447         public void AddGoal(AgentModel am, String goalName, float importanceOfSuccess, float importanceOfFailure)  throws UnknownGoalException { 
    448             Goal g = _goalLibrary.GetGoal(Name.ParseName(goalName)); 
    449             if (g != null) { 
    450               g.SetImportanceOfSuccess(am, importanceOfSuccess); 
    451               g.SetImportanceOfFailure(am, importanceOfFailure); 
    452               AddGoal(g); 
     228        public void actionSelectedForExecution(ValuedAction selectedAction) 
     229        { 
     230                String action; 
     231                String target=null; 
     232                Event e; 
     233                 
     234                if(_selectedAction == null) 
     235                { 
     236                        return; 
     237                } 
     238                 
     239                ListIterator<Symbol> li = _selectedAction.getName().GetLiteralList().listIterator(); 
     240             
     241            action = li.next().toString(); 
     242             
     243            if(li.hasNext()) { 
     244                target = li.next().toString(); 
    453245            } 
    454             else 
    455             { 
    456               throw new UnknownGoalException(goalName); 
     246             
     247            e = new Event(Constants.SELF,action,target); 
     248        _actionMonitor = new ActionMonitor(_selectedAction,e); 
     249         
     250        while(li.hasNext()) { 
     251                e.AddParameter(new Parameter("parameter",li.next().toString())); 
    457252            } 
    458         } 
    459          
    460         /** 
    461          * Adds a goal to the agent's Goal List 
    462          * @param goalName - the name of the Goal 
    463          * @param importanceOfSuccess - the goal's importance of success 
    464          * @param importanceOfFailure - the goal's importance of failure 
    465          * @throws UnknownGoalException - thrown if the goal is not specified 
    466          *                                                        in the GoalLibrary file. You can only add 
    467          *                                                                goals defined in the GoalLibrary. 
    468          */ 
    469         public void AddGoal(AgentModel am, String goalName)  throws UnknownGoalException { 
    470             Goal g = _goalLibrary.GetGoal(Name.ParseName(goalName)); 
    471             if (g != null) { 
    472               g.SetImportanceOfSuccess(am, 1); 
    473               g.SetImportanceOfFailure(am, 1); 
    474               AddGoal(g); 
    475             } 
    476             else 
    477             { 
    478               throw new UnknownGoalException(goalName); 
    479             } 
    480         } 
    481          
    482          
    483         /** 
    484          * Creates and Adds an intention to the set of intentions that the  
    485          * planner is currently trying to achieve (however the planner only 
    486          * picks one of them at each reasoning cycle) 
    487          *  
    488          * @param goal - the goal that we want to add 
    489          */ 
    490         public void AddIntention(AgentModel am, ActivePursuitGoal goal) { 
    491                 ArrayList<Plan> plans; 
    492                 Plan newPlan; 
    493                 Intention intention; 
    494                 String goalName = goal.getNameWithCharactersOrdered(); 
    495  
    496                 synchronized(this) 
    497                 { 
    498                         AgentLogger.GetInstance().logAndPrint("Adding 1st level intention: " + goal.getName()); 
    499                         intention = new Intention(am,goal); 
    500                          
    501                         plans = goal.getPlans(am); 
    502                         if(plans == null) 
    503                         { 
    504                                 newPlan = new Plan(_protectionConstraints, _isThreatStrat, goal.GetSuccessConditions()); 
    505                                 intention.AddPlan(newPlan); 
    506                         } 
    507                         else 
    508                         { 
    509                                 intention.AddPlans(plans); 
    510                         } 
    511                          
    512                         _intentions.put(goalName,intention); 
    513                         intention.ProcessIntentionActivation(am); 
    514                 } 
    515         } 
    516          
    517         public void AddSubIntention(AgentModel am, Intention mainIntention, ActivePursuitGoal goal) 
    518         { 
    519                 ArrayList<Plan> plans; 
    520                 Plan newPlan; 
    521                 Intention subIntention; 
    522                  
    523                  
    524                 subIntention = new Intention(am,goal); 
    525                 plans = goal.getPlans(am); 
    526                 if(plans == null) 
    527                 { 
    528                         newPlan = new Plan(_protectionConstraints, _isThreatStrat, goal.GetSuccessConditions()); 
    529                         subIntention.AddPlan(newPlan); 
    530                 } 
    531                 else 
    532                 { 
    533                         subIntention.AddPlans(plans); 
    534                 } 
    535                  
    536                 mainIntention.AddSubIntention(subIntention); 
    537         } 
    538          
    539         public void AddOptionsStrategy(IOptionsStrategy strategy) 
    540         { 
    541                 _optionStrategies.add(strategy); 
    542         } 
    543          
    544         /** 
    545          * Gets the agent's goals 
    546          * @return a list with the agent's goals 
    547          */ 
    548         public ArrayList<Goal> GetGoals() { 
    549                 return _goals; 
    550         } 
    551          
    552         /** 
    553          * Gets the library of goals (all goals specified for the domain) 
    554          * @return the GoalLibrary with all goals specified for the domain 
    555          */ 
    556         public GoalLibrary getGoalLibrary() { 
    557                 return _goalLibrary; 
    558         } 
    559          
    560         /** 
    561          * Gets the agent's emotional planner used in the deliberative reasoning process 
    562          * @return the agent's EmotionalPlanner 
    563          */ 
    564         public EmotionalPlanner getEmotionalPlanner() { 
    565             return _planner; 
    566         } 
    567          
    568         /** 
    569          * Gets a set of IntentionKeys 
    570          * @return a set with the keys used to store all intentions 
    571          */ 
    572         public Set<String> GetIntentionKeysSet() { 
    573                 synchronized(this) 
    574                 { 
    575                         return _intentions.keySet(); 
    576                 } 
    577         } 
    578  
    579         /** 
    580          * Gets a iterator that allows you to iterate over the set of active 
    581          * Intentions 
    582          * @return 
    583          */ 
    584         public Iterator<Intention> GetIntentionsIterator() { 
    585                 return _intentions.values().iterator(); 
    586         } 
    587          
    588         public void EnforceCopingStrategy(AgentModel am, String coping) 
    589         { 
    590                 Goal g; 
    591                 coping = coping.toLowerCase(); 
    592                 for(ListIterator<Goal> li = _goalLibrary.GetGoals();li.hasNext();) 
    593                 { 
    594                         g = (Goal) li.next(); 
    595                         if(g.getName().toString().toLowerCase().startsWith(coping) 
    596                                         || (coping.equals("standup") && g.getName().toString().startsWith("ReplyNegatively"))) 
    597                         { 
    598                                 AgentLogger.GetInstance().logAndPrint(""); 
    599                                 AgentLogger.GetInstance().logAndPrint("Enforcing coping strategy: " + g.getName()); 
    600                                 AgentLogger.GetInstance().logAndPrint(""); 
    601                                 g.IncreaseImportanceOfFailure(am, 2); 
    602                                 g.IncreaseImportanceOfSuccess(am, 2); 
    603                         } 
    604                 } 
    605         } 
    606          
    607         /** 
    608          * Determines an answer to a SpeechAct according to the agent's goals and plans 
    609          * @return the best answer to give according to its influence on the agent's 
    610          *                 goals and plans 
    611          */ 
    612         /* 
    613         public ValuedAction AnswerToSpeechAct(SpeechAct speechAct) { 
    614                 Step positiveAnswer; 
    615                 Step negativeAnswer; 
    616                 Name positiveSpeech; 
    617                 Name negativeSpeech; 
    618                 float positiveAnswerIntensity; 
    619                 float negativeAnswerIntensity; 
    620                 ArrayList bindings; 
    621                 Name action; 
    622                 Name goalFailure; 
    623                 float actionValue; 
    624                 Goal g; 
    625                  
    626                 positiveSpeech = Name.ParseName("Reply(" + speechAct.getSender() + "," +  speechAct.getMeaning() + ",positiveanswer)"); 
    627                 negativeSpeech = Name.ParseName("Reply(" + speechAct.getSender() + "," +  speechAct.getMeaning() + ",negativeanswer)"); 
    628                  
    629                 //check if the speech act refers to any goal 
    630                 synchronized (this) 
    631                 { 
    632                         ListIterator li = _goals.listIterator(); 
    633                         while(li.hasNext()) { 
    634                             g = (Goal) li.next(); 
    635                             if(g.GetName().GetFirstLiteral().toString().equals(speechAct.getMeaning())) { 
    636                                 //in this case, the user is suggesting that the agent should try to achieve this goal 
    637                                 //if the agent tried previously to achieve it and the goal failed, it will reply no way 
    638                                 goalFailure = Name.ParseName(g.GenerateGoalStatus(Goal.GOALFAILURE)); 
    639                                 bindings = KnowledgeBase.GetInstance().GetPossibleBindings(goalFailure); 
    640                                 if (bindings != null) { 
    641                                     return new ValuedAction(negativeSpeech,10); 
    642                                 } 
    643                                 else { 
    644                                     //if the goal didn't failed before, the agent will accept the user sugestion by increasing 
    645                                     //the goal's importance 
    646                                     g.IncreaseImportanceOfFailure(4); 
    647                                     g.IncreaseImportanceOfSuccess(4); 
    648                                     return new ValuedAction(positiveSpeech,10); 
    649                                 } 
    650                             } 
    651                         } 
    652                 } 
    653                  
    654                  
    655                 positiveAnswer = _planner.GetStep(positiveSpeech); 
    656                 if(positiveAnswer != null) { 
    657                         positiveAnswerIntensity = _planner.AppraiseAnswer(positiveAnswer); 
    658                 } 
    659                 else positiveAnswerIntensity = 0; 
    660                 negativeAnswer = _planner.GetStep(negativeSpeech); 
    661                 if(negativeAnswer != null) { 
    662                         negativeAnswerIntensity = _planner.AppraiseAnswer(negativeAnswer); 
    663                 } 
    664                 else negativeAnswerIntensity = 0; 
    665                  
    666                 if(positiveAnswerIntensity >= negativeAnswerIntensity) { 
    667                         if(positiveAnswer != null) 
    668                         { 
    669                                 action = positiveAnswer.getName(); 
    670                                 actionValue = positiveAnswerIntensity - negativeAnswerIntensity; 
    671                         } 
    672                         else return null; 
    673                 } 
    674                 else { 
    675                         if(negativeAnswer != null) 
    676                         { 
    677                                 action = negativeAnswer.getName(); 
    678                                 actionValue = negativeAnswerIntensity - positiveAnswerIntensity; 
    679                         } 
    680                         else return null; 
    681                 } 
    682                  
    683                 return new ValuedAction(action,actionValue); 
    684         } 
    685         */ 
    686          
    687         @Override 
    688         public void update(AgentModel am, Event event) { 
    689                  
    690                 CheckLinks(am); 
    691          
    692                  
    693                 if(_actionMonitor != null && _actionMonitor.matchEvent(event)) { 
    694                     if(_actionMonitor.getStep().getAgent().isGrounded() &&   
    695                                 !_actionMonitor.getStep().getAgent().toString().equals(Constants.SELF)) 
    696                     { 
    697                         //the agent was waiting for an action of other agent to be complete 
    698                         //since the step of another agent may contain unbound variables, 
    699                         //we cannot just compare the names, we need to try to unify them 
    700                         if(Unifier.Unify(event.toStepName(),  
    701                                         _actionMonitor.getStep().getName()) != null) 
    702                         { 
    703                                 _actionMonitor.getStep().IncreaseProbability(am); 
    704                                 //System.out.println("Calling updateEffectsProbability (other's action: step completed)"); 
    705                                 _actionMonitor.getStep().updateEffectsProbability(am); 
    706                         } 
    707                         else 
    708                         { 
    709                                 for(IActionFailureStrategy s : _actionFailureStrategies) 
    710                                 { 
    711                                         s.perceiveActionFailure(am, _actionMonitor.getStep()); 
    712                                 } 
    713                      
    714                                 _actionMonitor.getStep().DecreaseProbability(am); 
    715                         } 
    716                     } 
    717                     else  
    718                     { 
    719                         for(IActionSuccessStrategy s : _actionSuccessStrategies) 
    720                         { 
    721                                 s.perceiveActionSuccess(am, _actionMonitor.getStep()); 
    722                         } 
    723                         //System.out.println("Calling updateEffectsProbability (self: step completed)"); 
    724                         _actionMonitor.getStep().updateEffectsProbability(am); 
    725                     } 
    726                                  
    727                         UpdateProbabilities(); 
    728                         _actionMonitor = null; 
    729                 } 
    730         } 
    731          
    732         public ArrayList<ActivePursuitGoal> options(AgentModel am) 
    733         { 
    734                 Goal g; 
    735                 ActivePursuitGoal aGoal; 
    736                 ListIterator<Goal> li; 
    737                 ListIterator<SubstitutionSet> li2; 
    738                 ActivePursuitGoal desire; 
    739                 SubstitutionSet subSet; 
    740                 ArrayList<SubstitutionSet> substitutionSets; 
    741                 ArrayList<ActivePursuitGoal> options; 
    742                  
    743                 options = new ArrayList<ActivePursuitGoal>();    
    744                  
    745                  
    746                 //TODO optimize the goal activation verification 
    747                 synchronized (this) 
    748                 { 
    749                         li = _goals.listIterator(); 
    750                         while (li.hasNext()) { 
    751                                 g = (Goal) li.next(); 
    752                                 if (g instanceof ActivePursuitGoal) { 
    753                                         aGoal = (ActivePursuitGoal) g; 
    754                                          
    755                                          
    756                                         substitutionSets = Condition.CheckActivation(am, aGoal.GetPreconditions());  
    757                                         if(substitutionSets != null) { 
    758                                                 li2 = substitutionSets.listIterator(); 
    759                                                 while(li2.hasNext()) { 
    760                                                          
    761                                                         subSet = (SubstitutionSet) li2.next(); 
    762                                                          
    763                                                         desire = (ActivePursuitGoal) aGoal.clone(); 
    764                                                         desire.MakeGround(subSet.GetSubstitutions()); 
    765                                                          
    766                                                         //In addition to testing the preconditions, we only add a goal 
    767                                                         // as a desire if it's success and failure conditions are not satisfied 
    768                                                          
    769                                                         if(!desire.CheckSuccess(am) && !desire.CheckFailure(am)) 
    770                                                         { 
    771  
    772                                                                         options.add(desire);     
    773                                                         } 
    774                                                 } 
    775                                         } 
    776                                 } 
    777                         } 
    778                 } 
    779                  
    780                 return options; 
    781         } 
    782          
    783         public ActivePursuitGoal Filter(AgentModel am, ArrayList<ActivePursuitGoal> options) { 
    784                 ActivePursuitGoal g;  
    785                 ActivePursuitGoal maxGoal = null; 
    786                 float maxUtility; 
    787                 // expected utility of achieving a goal 
    788                 float EU; 
    789                  
    790                 maxUtility = -200; 
    791                  
    792                 ListIterator<ActivePursuitGoal> li = options.listIterator(); 
    793                 while(li.hasNext()) 
    794                 { 
    795                         g = li.next(); 
    796                         if(!ContainsIntention(g)) 
    797                         {                
    798                                 EU = _EUStrategy.getExpectedUtility(am, g); 
    799                                  
    800                                 if(EU > maxUtility) 
    801                                 { 
    802                                         maxUtility = EU; 
    803                                         maxGoal = g; 
    804                                 } 
    805                         } 
    806                 } 
    807                  
    808                 if(maxGoal != null) 
    809                 { 
    810                         if(maxUtility >= MINIMUMUTILITY) 
    811                         { 
    812                                 if(_currentIntention == null || 
    813                                                 maxUtility > _EUStrategy.getExpectedUtility(am,_currentIntention)*SELECTIONTHRESHOLD) 
    814                                 { 
    815                                         return maxGoal; 
    816                                 } 
    817                         } 
    818                 } 
    819                  
    820                  
    821                 return null; 
    822         } 
    823          
    824         /** 
    825          * Filters the most relevant intention from the set of possible intentions/goals. 
    826          * Corresponds to Focusing on a given goal 
    827          * @return - the most relevant intention (the one with highest expected utility) 
    828          */ 
    829         public Intention Filter2ndLevel(AgentModel am) { 
    830                 Iterator<Intention> it; 
    831                 Intention intention; 
    832                 float highestUtility;  
    833                 Intention maxIntention = null; 
    834                 float EU; 
    835                  
    836                 if(_currentIntention != null) 
    837                 { 
    838                         highestUtility = _EUStrategy.getExpectedUtility(am, _currentIntention); 
    839                          
    840                         maxIntention = _currentIntention; 
    841                         //TODO selection threshold here! 
    842                 } 
    843                 else 
    844                 { 
    845                         maxIntention = null; 
    846                         highestUtility = -200; 
    847                 } 
    848                  
    849                 synchronized(this) 
    850                 { 
    851                         it = _intentions.values().iterator(); 
    852                          
    853  
    854                         while (it.hasNext()) { 
    855                                  
    856                                 intention = (Intention) it.next(); 
    857                                  
    858                                 if(intention != _currentIntention)  
    859                                 { 
    860                                         EU = _EUStrategy.getExpectedUtility(am, intention);  
    861                                          
    862                                         if(EU > highestUtility && EU > MINIMUMUTILITY) 
    863                                         { 
    864                                                 highestUtility = EU; 
    865                                                 maxIntention = intention; 
    866                                         } 
    867                                 } 
    868                         } 
    869                 } 
    870                  
    871                 if(this._currentIntention != maxIntention) 
    872                 { 
    873                         AgentLogger.GetInstance().logAndPrint("Switching 2nd level intention from " + this._currentIntention + " to " + maxIntention); 
    874                 } 
    875                  
    876                 this._currentIntention = maxIntention; 
    877                  
    878                 return maxIntention; 
     253             
     254            _selectedActionEmotion = null; 
     255                _selectedAction = null; 
    879256        } 
    880257         
     
    904281                 
    905282                //deliberation; 
    906                 ActivePursuitGoal g = Filter(am, this._options); 
     283                ActivePursuitGoal g = filter(am, this._options); 
    907284                 
    908285                if(g != null) 
    909286                { 
    910                         AddIntention(am, g); 
     287                        addIntention(am, g); 
    911288                } 
    912289                 
    913290                //means-end reasoning 
    914                 _currentIntention = Filter2ndLevel(am); 
     291                _currentIntention = filter2ndLevel(am); 
    915292                if(_currentIntention != null) { 
    916293                        i = _currentIntention.GetSubIntention(); 
     
    928305                        if(i.getGoal().CheckSuccess(am)) 
    929306                        { 
    930                                 RemoveIntention(i); 
     307                                removeIntention(i); 
    931308                                for(IGoalSuccessStrategy s: _goalSuccessStrategies) 
    932309                                { 
     
    934311                                } 
    935312                                i.ProcessIntentionSuccess(am); 
    936                                 cancelAction(am); 
    937313                        } 
    938314                        else if(i.getGoal().CheckFailure(am)) 
    939315                        { 
    940                                 RemoveIntention(i); 
     316                                removeIntention(i); 
    941317                                for(IGoalFailureStrategy s: _goalFailureStrategies) 
    942318                                { 
     
    958334                                if(i.IsStrongCommitment()) 
    959335                                { 
    960                                         RemoveIntention(i);      
     336                                        removeIntention(i);      
    961337                                } 
    962338                                cancelAction(am); 
    963339                        } 
    964                         else if(!i.getGoal().checkPreconditions(am)) 
     340                        else if(!i.IsStrongCommitment() && !i.getGoal().checkPreconditions(am)) 
    965341                        { 
    966342                                //this is done only if the agent hasn't tried to do anything yet, he cancels the goal out 
    967343                                //if the preconditions are not yet established 
    968                                 if(!i.IsStrongCommitment()) 
    969                                 { 
    970                                         RemoveIntention(i); 
    971                                 } 
     344                                removeIntention(i); 
    972345                        } 
    973346                        else 
    974347                        { 
    975                                 _selectedPlan = _planner.ThinkAbout(am, i); 
     348                                _selectedPlan = _planner.ThinkAbout(am,this, i); 
     349                        } 
     350                         
     351                        if(_selectedPlan == null && i.IsStrongCommitment() && !i.getGoal().checkPreconditions(am)) 
     352                        { 
     353                                i.ProcessIntentionCancel(am); 
     354                                removeIntention(i); 
    976355                        } 
    977356                         
     
    990369                                        if(copingAction instanceof ActivePursuitGoal) 
    991370                                        { 
    992                                                 AddSubIntention(am, _currentIntention, (ActivePursuitGoal) copingAction);        
     371                                                addSubIntention(am, _currentIntention, (ActivePursuitGoal) copingAction);        
    993372                                        } 
    994373                                        else if(!actionName.startsWith("Inference") && !actionName.endsWith("Appraisal") && !actionName.startsWith("SA")) 
     
    1033412                                                  am.getMemory().getSemanticMemory().Tell(eff.GetEffect().getName(), eff.GetEffect().GetValue().toString()); 
    1034413                                            } 
    1035                                             this.CheckLinks(am); 
     414                                            this.checkLinks(am); 
    1036415                                        } 
    1037416                                        else 
     
    1052431                } 
    1053432                 
    1054                 return GetSelectedAction(); 
     433                return getSelectedAction(); 
     434        } 
     435         
     436        public void addActionFailureStrategy(IActionFailureStrategy strat) 
     437        { 
     438                _actionFailureStrategies.add(strat); 
     439        } 
     440         
     441        public void addActionSuccessStrategy(IActionSuccessStrategy strat) 
     442        { 
     443                _actionSuccessStrategies.add(strat); 
     444        } 
     445         
     446        /** 
     447         * Adds a goal to the agent's Goal List 
     448         * @param goalName - the name of the Goal 
     449         * @param importanceOfSuccess - the goal's importance of success 
     450         * @param importanceOfFailure - the goal's importance of failure 
     451         * @throws UnknownGoalException - thrown if the goal is not specified 
     452         *                                                        in the GoalLibrary file. You can only add 
     453         *                                                                goals defined in the GoalLibrary. 
     454         */ 
     455        public void addGoal(AgentModel am, String goalName)  throws UnknownGoalException { 
     456            Goal g = am.getGoalLibrary().GetGoal(Name.ParseName(goalName)); 
     457            if (g != null) { 
     458              g.SetImportanceOfSuccess(am, 1); 
     459              g.SetImportanceOfFailure(am, 1); 
     460              addGoal(g); 
     461            } 
     462            else 
     463            { 
     464              throw new UnknownGoalException(goalName); 
     465            } 
     466        } 
     467         
     468        /** 
     469         * Adds a goal to the agent's Goal List 
     470         * @param goalName - the name of the Goal 
     471         * @param importanceOfSuccess - the goal's importance of success 
     472         * @param importanceOfFailure - the goal's importance of failure 
     473         * @throws UnknownGoalException - thrown if the goal is not specified 
     474         *                                                        in the GoalLibrary file. You can only add 
     475         *                                                                goals defined in the GoalLibrary. 
     476         */ 
     477        public void addGoal(AgentModel am, String goalName, float importanceOfSuccess, float importanceOfFailure)  throws UnknownGoalException { 
     478                 
     479            Goal g = am.getGoalLibrary().GetGoal(Name.ParseName(goalName)); 
     480            if (g != null) { 
     481              g.SetImportanceOfSuccess(am, importanceOfSuccess); 
     482              g.SetImportanceOfFailure(am, importanceOfFailure); 
     483              addGoal(g); 
     484            } 
     485            else 
     486            { 
     487              throw new UnknownGoalException(goalName); 
     488            } 
     489        } 
     490         
     491        /** 
     492         * Adds a goal to the agent's Goal List 
     493         * @param goal - the goal to add 
     494         */ 
     495        public void addGoal(Goal goal) { 
     496                InterestGoal iGoal; 
     497                ArrayList<Condition> protectionConstraints; 
     498                ListIterator<Condition> li; 
     499                 
     500                synchronized (this) { 
     501                        if(!_goals.contains(goal)) { 
     502                            _goals.add(goal); 
     503                            if (goal instanceof InterestGoal) { 
     504                                        iGoal = (InterestGoal) goal; 
     505                                        protectionConstraints = iGoal.getProtectionConstraints(); 
     506                                        if(protectionConstraints != null) 
     507                                        { 
     508                                                li = protectionConstraints.listIterator(); 
     509                                                while(li.hasNext()) 
     510                                                { 
     511                                                        addProtectionConstraint(new ProtectedCondition(iGoal, (Condition) li.next())); 
     512                                                } 
     513                                        } 
     514                                } 
     515                        } 
     516                } 
     517        } 
     518         
     519        public void addGoalFailureStrategy(IGoalFailureStrategy strat) 
     520        { 
     521                _goalFailureStrategies.add(strat); 
     522        } 
     523         
     524        public void addGoalSuccessStrategy(IGoalSuccessStrategy strat) 
     525        { 
     526                _goalSuccessStrategies.add(strat); 
     527        } 
     528         
     529        /** 
     530         * Creates and Adds an intention to the set of intentions that the  
     531         * planner is currently trying to achieve (however the planner only 
     532         * picks one of them at each reasoning cycle) 
     533         *  
     534         * @param goal - the goal that we want to add 
     535         */ 
     536        public void addIntention(AgentModel am, ActivePursuitGoal goal) { 
     537                ArrayList<Plan> plans; 
     538                Plan newPlan; 
     539                Intention intention; 
     540                String goalName = goal.getNameWithCharactersOrdered(); 
     541 
     542                synchronized(this) 
     543                { 
     544                        AgentLogger.GetInstance().logAndPrint("Adding 1st level intention: " + goal.getName()); 
     545                        intention = new Intention(am,goal); 
     546                         
     547                        plans = goal.getPlans(am); 
     548                        if(plans == null) 
     549                        { 
     550                                newPlan = new Plan(_protectionConstraints, _isThreatStrat, goal.GetSuccessConditions()); 
     551                                intention.AddPlan(newPlan); 
     552                        } 
     553                        else 
     554                        { 
     555                                intention.AddPlans(plans); 
     556                        } 
     557                         
     558                        _intentions.put(goalName,intention); 
     559                        intention.ProcessIntentionActivation(am); 
     560                } 
     561        } 
     562         
     563        public void addOptionsStrategy(IOptionsStrategy strategy) 
     564        { 
     565                _optionStrategies.add(strategy); 
     566        } 
     567         
     568        /** 
     569         * Adds a ProtectionConstraint to the DeliberativeLayer. The planner will detect 
     570         * when there are threats to these ProtectionConstraints and deal with them 
     571         * with emotion-focused coping strategies.  
     572         *  
     573         * @param cond - the ProtectedCondition to add 
     574         * @see ProtectedCondition 
     575         */ 
     576        public void addProtectionConstraint(ProtectedCondition cond) { 
     577                _protectionConstraints.add(cond); 
     578        } 
     579         
     580        public void addSubIntention(AgentModel am, Intention mainIntention, ActivePursuitGoal goal) 
     581        { 
     582                ArrayList<Plan> plans; 
     583                Plan newPlan; 
     584                Intention subIntention; 
     585                 
     586                 
     587                subIntention = new Intention(am,goal); 
     588                plans = goal.getPlans(am); 
     589                if(plans == null) 
     590                { 
     591                        newPlan = new Plan(_protectionConstraints, _isThreatStrat, goal.GetSuccessConditions()); 
     592                        subIntention.AddPlan(newPlan); 
     593                } 
     594                else 
     595                { 
     596                        subIntention.AddPlans(plans); 
     597                } 
     598                 
     599                mainIntention.AddSubIntention(subIntention); 
     600        } 
     601         
     602        @Override 
     603        public void appraisal(AgentModel am, Event e, AppraisalFrame as) { 
     604        } 
     605         
     606        public void appraiseSelfActionFailed(Event e) 
     607        { 
     608                if(_actionMonitor != null) 
     609                { 
     610                        if(_actionMonitor.matchEvent(e)) 
     611                        { 
     612                                _actionMonitor = null; 
     613                        } 
     614                } 
    1055615        } 
    1056616         
     
    1069629        } 
    1070630         
    1071         public void AppraiseSelfActionFailed(Event e) 
    1072         { 
    1073                 if(_actionMonitor != null) 
    1074                 { 
    1075                         if(_actionMonitor.matchEvent(e)) 
    1076                         { 
    1077                                 _actionMonitor = null; 
    1078                         } 
    1079                 } 
     631         
     632        /** 
     633         * Changes a Goal's Importance 
     634         * @param goalName - the name of the goal to change 
     635         * @param importance - the new value for the importance 
     636         * @param importanceType - the type of importance:  
     637         *                                                 the String "CIS" changes the importance of success 
     638         *                                                 the String "CIF" changes the importance of failure 
     639         */ 
     640        public void changeGoalImportance(AgentModel am, String goalName, float importance, String importanceType) { 
     641                ListIterator<Goal> li; 
     642                 
     643                synchronized (this) { 
     644                        li = _goals.listIterator(); 
     645                        Goal g; 
     646                         
     647                        while(li.hasNext()) { 
     648                                g = (Goal) li.next(); 
     649                                if(goalName.equals(g.getName().toString())) { 
     650                                        if(importanceType.equals("CIS")) { 
     651                                                g.SetImportanceOfSuccess(am, importance); 
     652                                        } 
     653                                        else { 
     654                                                g.SetImportanceOfFailure(am, importance); 
     655                                        } 
     656                                        break; 
     657                                } 
     658                        }        
     659                } 
     660        } 
     661         
     662        /** 
     663         * Updates all the plans that the deliberative layer is currently working with, i.e., 
     664         * it updates all plans of all current active intentions 
     665         */ 
     666        public void checkLinks(AgentModel am) { 
     667                Iterator<Intention> it; 
     668                 
     669                synchronized(this) 
     670                { 
     671                        it = _intentions.values().iterator(); 
     672                        while (it.hasNext()) { 
     673                                ((Intention) it.next()).CheckLinks(am); 
     674                        } 
     675                } 
     676        } 
     677         
     678        public boolean containsIntention(ActivePursuitGoal goal) 
     679        { 
     680                String goalName = goal.getNameWithCharactersOrdered(); 
     681                 
     682                return _intentions.containsKey(goalName); 
     683                 
     684                 
     685                /* 
     686                while(it.hasNext()) 
     687                { 
     688                        i = (Intention) it.next(); 
     689                        if (i.containsIntention(goalName)) return true; 
     690                } 
     691                 
     692                return false;*/ 
     693        } 
     694         
     695        @Override 
     696        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     697                return null; 
     698        } 
     699         
     700        @Override 
     701        public IComponent createModelOfOther() { 
     702                return new DeliberativeProcess(_planner); 
     703        } 
     704         
     705        public ActivePursuitGoal filter(AgentModel am, ArrayList<ActivePursuitGoal> options) { 
     706                ActivePursuitGoal g;  
     707                ActivePursuitGoal maxGoal = null; 
     708                float maxUtility; 
     709                // expected utility of achieving a goal 
     710                float EU; 
     711                 
     712                maxUtility = -200; 
     713                 
     714                ListIterator<ActivePursuitGoal> li = options.listIterator(); 
     715                while(li.hasNext()) 
     716                { 
     717                        g = li.next(); 
     718                        if(!containsIntention(g)) 
     719                        {                
     720                                EU = _EUStrategy.getExpectedUtility(am, g); 
     721                                 
     722                                if(EU > maxUtility) 
     723                                { 
     724                                        maxUtility = EU; 
     725                                        maxGoal = g; 
     726                                } 
     727                        } 
     728                } 
     729                 
     730                if(maxGoal != null) 
     731                { 
     732                        if(maxUtility >= MINIMUMUTILITY) 
     733                        { 
     734                                if(_currentIntention == null || 
     735                                                maxUtility > _EUStrategy.getExpectedUtility(am,_currentIntention)*SELECTIONTHRESHOLD) 
     736                                { 
     737                                        return maxGoal; 
     738                                } 
     739                        } 
     740                } 
     741                 
     742                 
     743                return null; 
     744        } 
     745         
     746        /** 
     747         * Filters the most relevant intention from the set of possible intentions/goals. 
     748         * Corresponds to Focusing on a given goal 
     749         * @return - the most relevant intention (the one with highest expected utility) 
     750         */ 
     751        public Intention filter2ndLevel(AgentModel am) { 
     752                Iterator<Intention> it; 
     753                Intention intention; 
     754                float highestUtility;  
     755                Intention maxIntention = null; 
     756                float EU; 
     757                 
     758                if(_currentIntention != null) 
     759                { 
     760                        highestUtility = _EUStrategy.getExpectedUtility(am, _currentIntention); 
     761                         
     762                        maxIntention = _currentIntention; 
     763                        //TODO selection threshold here! 
     764                } 
     765                else 
     766                { 
     767                        maxIntention = null; 
     768                        highestUtility = -200; 
     769                } 
     770                 
     771                synchronized(this) 
     772                { 
     773                        it = _intentions.values().iterator(); 
     774                         
     775 
     776                        while (it.hasNext()) { 
     777                                 
     778                                intention = (Intention) it.next(); 
     779                                 
     780                                if(intention != _currentIntention)  
     781                                { 
     782                                        EU = _EUStrategy.getExpectedUtility(am, intention);  
     783                                         
     784                                        if(EU > highestUtility && EU > MINIMUMUTILITY) 
     785                                        { 
     786                                                highestUtility = EU; 
     787                                                maxIntention = intention; 
     788                                        } 
     789                                } 
     790                        } 
     791                } 
     792                 
     793                if(this._currentIntention != maxIntention) 
     794                { 
     795                        AgentLogger.GetInstance().logAndPrint("Switching 2nd level intention from " + this._currentIntention + " to " + maxIntention); 
     796                } 
     797                 
     798                this._currentIntention = maxIntention; 
     799                 
     800                return maxIntention; 
     801        } 
     802         
     803         
     804        public IDetectThreatStrategy getDetectThreatStrategy() 
     805        { 
     806                return _isThreatStrat; 
     807        } 
     808         
     809        /** 
     810         * Gets the agent's emotional planner used in the deliberative reasoning process 
     811         * @return the agent's EmotionalPlanner 
     812         */ 
     813        public EmotionalPlanner getEmotionalPlanner() { 
     814            return _planner; 
     815        } 
     816         
     817        public float getExpectedUtility(AgentModel am, ActivePursuitGoal g) { 
     818                return _UStrategy.getUtility(am, g) * _PStrategy.getProbability(am, g); 
     819        } 
     820         
     821        public float getExpectedUtility(AgentModel am, Intention i) { 
     822                return _UStrategy.getUtility(am, i.getGoal()) * _PStrategy.getProbability(am, i); 
     823        } 
     824         
     825        public IExpectedUtilityStrategy getExpectedUtilityStrategy() 
     826        { 
     827                return _EUStrategy; 
     828        } 
     829         
     830        /** 
     831         * Gets the agent's goals 
     832         * @return a list with the agent's goals 
     833         */ 
     834        public ArrayList<Goal> getGoals() { 
     835                return _goals; 
     836        } 
     837 
     838        /** 
     839         * Gets a set of IntentionKeys 
     840         * @return a set with the keys used to store all intentions 
     841         */ 
     842        public Set<String> getIntentionKeysSet() { 
     843                synchronized(this) 
     844                { 
     845                        return _intentions.keySet(); 
     846                } 
     847        } 
     848         
     849         
     850         
     851        /** 
     852         * Gets a iterator that allows you to iterate over the set of active 
     853         * Intentions 
     854         * @return 
     855         */ 
     856        public Iterator<Intention> getIntentionsIterator() { 
     857                return _intentions.values().iterator(); 
     858        } 
     859         
     860        public IProbabilityStrategy getProbabilityStrategy() 
     861        { 
     862                return _PStrategy; 
    1080863        } 
    1081864         
     
    1085868         *             if no such action exists  
    1086869         */ 
    1087         private ValuedAction GetSelectedAction() { 
     870        private ValuedAction getSelectedAction() { 
    1088871          
    1089872                Event e; 
     
    1149932        } 
    1150933         
    1151         public void actionSelectedForExecution(ValuedAction selectedAction) 
    1152         { 
    1153                 String action; 
    1154                 String target=null; 
    1155                 Event e; 
    1156                  
    1157                 if(_selectedAction == null) 
    1158                 { 
    1159                         return; 
    1160                 } 
    1161                  
    1162                 ListIterator<Symbol> li = _selectedAction.getName().GetLiteralList().listIterator(); 
    1163              
    1164             action = li.next().toString(); 
    1165              
    1166             if(li.hasNext()) { 
    1167                 target = li.next().toString(); 
    1168             } 
    1169              
    1170             e = new Event(Constants.SELF,action,target); 
    1171         _actionMonitor = new ActionMonitor(_selectedAction,e); 
    1172          
    1173         while(li.hasNext()) { 
    1174                 e.AddParameter(new Parameter("parameter",li.next().toString())); 
    1175             } 
    1176              
    1177             _selectedActionEmotion = null; 
    1178                 _selectedAction = null; 
     934        public IGetUtilityForOthers getUtilityForOthersStrategy() 
     935        { 
     936                return _UOthersStrategy; 
     937        } 
     938         
     939        public IUtilityStrategy getUtilityStrategy() 
     940        { 
     941                return _UStrategy; 
     942        } 
     943         
     944        @Override 
     945        public void initialize(AgentModel ag) {  
     946        } 
     947         
     948        @Override 
     949        public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
     950        } 
     951         
     952        @Override 
     953        public String name() { 
     954                return DeliberativeProcess.NAME; 
     955        } 
     956         
     957        public ArrayList<ActivePursuitGoal> options(AgentModel am) 
     958        { 
     959                Goal g; 
     960                ActivePursuitGoal aGoal; 
     961                ListIterator<Goal> li; 
     962                ListIterator<SubstitutionSet> li2; 
     963                ActivePursuitGoal desire; 
     964                SubstitutionSet subSet; 
     965                ArrayList<SubstitutionSet> substitutionSets; 
     966                ArrayList<ActivePursuitGoal> options; 
     967                 
     968                options = new ArrayList<ActivePursuitGoal>();    
     969                 
     970                 
     971                //TODO optimize the goal activation verification 
     972                synchronized (this) 
     973                { 
     974                        li = _goals.listIterator(); 
     975                        while (li.hasNext()) { 
     976                                g = (Goal) li.next(); 
     977                                if (g instanceof ActivePursuitGoal) { 
     978                                        aGoal = (ActivePursuitGoal) g; 
     979                                         
     980                                         
     981                                        substitutionSets = Condition.CheckActivation(am, aGoal.GetPreconditions());  
     982                                        if(substitutionSets != null) { 
     983                                                li2 = substitutionSets.listIterator(); 
     984                                                while(li2.hasNext()) { 
     985                                                         
     986                                                        subSet = (SubstitutionSet) li2.next(); 
     987                                                         
     988                                                        desire = (ActivePursuitGoal) aGoal.clone(); 
     989                                                        desire.MakeGround(subSet.GetSubstitutions()); 
     990                                                         
     991                                                        //In addition to testing the preconditions, we only add a goal 
     992                                                        // as a desire if it's success and failure conditions are not satisfied 
     993                                                         
     994                                                        if(!desire.CheckSuccess(am) && !desire.CheckFailure(am)) 
     995                                                        { 
     996 
     997                                                                        options.add(desire);     
     998                                                        } 
     999                                                } 
     1000                                        } 
     1001                                } 
     1002                        } 
     1003                } 
     1004                 
     1005                return options; 
     1006        } 
     1007         
     1008        @Override 
     1009        public AppraisalFrame reappraisal(AgentModel am) { 
     1010                return null; 
     1011        } 
     1012         
     1013        /** 
     1014         * Removes all the agent's goals 
     1015         * 
     1016         */ 
     1017        public void removeAllGoals() { 
     1018                 
     1019                synchronized (this) 
     1020                { 
     1021                        _goals.clear(); 
     1022                        _options.clear(); 
     1023                        _intentions.clear(); 
     1024                } 
     1025        } 
     1026         
     1027        /** 
     1028         * Removes a given goal from the agent's goal list 
     1029         * @param goalName - the name of the goal to remove 
     1030         */ 
     1031        public void removeGoal(String goalName) { 
     1032                Goal g; 
     1033                 
     1034                synchronized (this) 
     1035                { 
     1036                        for(int i=0; i < _goals.size(); i++) { 
     1037                                g = (Goal) _goals.get(i); 
     1038                                if(goalName.equals(g.getName().toString())) { 
     1039                                        _goals.remove(i); 
     1040                                        break; 
     1041                                } 
     1042                        } 
     1043                } 
     1044        } 
     1045 
     1046 
     1047        public void removeIntention(Intention i) 
     1048        { 
     1049                if(i.isRootIntention()) 
     1050                { 
     1051                        synchronized(this) 
     1052                        { 
     1053                                _intentions.remove(i.getGoal().getNameWithCharactersOrdered().toString()); 
     1054                        } 
     1055                        _currentIntention = null; 
     1056                } 
     1057                else 
     1058                { 
     1059                        //TODO remove or change this 
     1060                        this.removeIntention(i.getParentIntention()); 
     1061                        //i.getParentIntention().RemoveSubIntention(); 
     1062                } 
    11791063        } 
    11801064         
     
    11921076                _selectedActionEmotion = null; 
    11931077        } 
    1194          
    1195         public void RemoveIntention(Intention i) 
    1196         { 
    1197                 if(i.isRootIntention()) 
    1198                 { 
    1199                         synchronized(this) 
    1200                         { 
    1201                                 _intentions.remove(i.getGoal().getNameWithCharactersOrdered().toString()); 
    1202                         } 
    1203                         _currentIntention = null; 
    1204                 } 
    1205                 else 
    1206                 { 
    1207                         //TODO remove or change this 
    1208                         this.RemoveIntention(i.getParentIntention()); 
    1209                         //i.getParentIntention().RemoveSubIntention(); 
    1210                 } 
    1211         } 
    1212          
    1213         /** 
    1214          * Forces the recalculation of all plan's probability 
    1215          */ 
    1216         public void UpdateProbabilities() { 
    1217                  
    1218                 Iterator<Intention> it;  
    1219                  
    1220                 it = _intentions.values().iterator(); 
    1221                 while (it.hasNext()) { 
    1222                         ((Intention) it.next()).UpdateProbabilities(); 
    1223                 } 
    1224         } 
    1225  
    1226  
    1227         public float getExpectedUtility(AgentModel am, ActivePursuitGoal g) { 
    1228                 return _UStrategy.getUtility(am, g) * _PStrategy.getProbability(am, g); 
    1229         } 
    1230          
    1231         public float getExpectedUtility(AgentModel am, Intention i) { 
    1232                 return _UStrategy.getUtility(am, i.getGoal()) * _PStrategy.getProbability(am, i); 
    1233         } 
    1234  
     1078 
     1079        public void setDetectThreatStrategy(IDetectThreatStrategy strat) 
     1080        { 
     1081                _isThreatStrat = strat; 
     1082        } 
     1083 
     1084        public void setExpectedUtilityStrategy(IExpectedUtilityStrategy strategy) 
     1085        { 
     1086                _EUStrategy = strategy; 
     1087        } 
     1088         
     1089        public void setProbabilityStrategy(IProbabilityStrategy strategy) 
     1090        { 
     1091                _PStrategy = strategy; 
     1092        } 
     1093 
     1094 
     1095        public void setUtilityForOthersStrategy(IGetUtilityForOthers strat) 
     1096        { 
     1097                _UOthersStrategy = strat; 
     1098        } 
     1099 
     1100 
     1101        public void setUtilityStrategy(IUtilityStrategy strategy) 
     1102        { 
     1103                _UStrategy = strategy; 
     1104        } 
     1105         
     1106        /** 
     1107         * Determines an answer to a SpeechAct according to the agent's goals and plans 
     1108         * @return the best answer to give according to its influence on the agent's 
     1109         *                 goals and plans 
     1110         */ 
     1111        /* 
     1112        public ValuedAction AnswerToSpeechAct(SpeechAct speechAct) { 
     1113                Step positiveAnswer; 
     1114                Step negativeAnswer; 
     1115                Name positiveSpeech; 
     1116                Name negativeSpeech; 
     1117                float positiveAnswerIntensity; 
     1118                float negativeAnswerIntensity; 
     1119                ArrayList bindings; 
     1120                Name action; 
     1121                Name goalFailure; 
     1122                float actionValue; 
     1123                Goal g; 
     1124                 
     1125                positiveSpeech = Name.ParseName("Reply(" + speechAct.getSender() + "," +  speechAct.getMeaning() + ",positiveanswer)"); 
     1126                negativeSpeech = Name.ParseName("Reply(" + speechAct.getSender() + "," +  speechAct.getMeaning() + ",negativeanswer)"); 
     1127                 
     1128                //check if the speech act refers to any goal 
     1129                synchronized (this) 
     1130                { 
     1131                        ListIterator li = _goals.listIterator(); 
     1132                        while(li.hasNext()) { 
     1133                            g = (Goal) li.next(); 
     1134                            if(g.GetName().GetFirstLiteral().toString().equals(speechAct.getMeaning())) { 
     1135                                //in this case, the user is suggesting that the agent should try to achieve this goal 
     1136                                //if the agent tried previously to achieve it and the goal failed, it will reply no way 
     1137                                goalFailure = Name.ParseName(g.GenerateGoalStatus(Goal.GOALFAILURE)); 
     1138                                bindings = KnowledgeBase.GetInstance().GetPossibleBindings(goalFailure); 
     1139                                if (bindings != null) { 
     1140                                    return new ValuedAction(negativeSpeech,10); 
     1141                                } 
     1142                                else { 
     1143                                    //if the goal didn't failed before, the agent will accept the user sugestion by increasing 
     1144                                    //the goal's importance 
     1145                                    g.IncreaseImportanceOfFailure(4); 
     1146                                    g.IncreaseImportanceOfSuccess(4); 
     1147                                    return new ValuedAction(positiveSpeech,10); 
     1148                                } 
     1149                            } 
     1150                        } 
     1151                } 
     1152                 
     1153                 
     1154                positiveAnswer = _planner.GetStep(positiveSpeech); 
     1155                if(positiveAnswer != null) { 
     1156                        positiveAnswerIntensity = _planner.AppraiseAnswer(positiveAnswer); 
     1157                } 
     1158                else positiveAnswerIntensity = 0; 
     1159                negativeAnswer = _planner.GetStep(negativeSpeech); 
     1160                if(negativeAnswer != null) { 
     1161                        negativeAnswerIntensity = _planner.AppraiseAnswer(negativeAnswer); 
     1162                } 
     1163                else negativeAnswerIntensity = 0; 
     1164                 
     1165                if(positiveAnswerIntensity >= negativeAnswerIntensity) { 
     1166                        if(positiveAnswer != null) 
     1167                        { 
     1168                                action = positiveAnswer.getName(); 
     1169                                actionValue = positiveAnswerIntensity - negativeAnswerIntensity; 
     1170                        } 
     1171                        else return null; 
     1172                } 
     1173                else { 
     1174                        if(negativeAnswer != null) 
     1175                        { 
     1176                                action = negativeAnswer.getName(); 
     1177                                actionValue = negativeAnswerIntensity - positiveAnswerIntensity; 
     1178                        } 
     1179                        else return null; 
     1180                } 
     1181                 
     1182                return new ValuedAction(action,actionValue); 
     1183        } 
     1184        */ 
     1185         
    12351186        @Override 
    1236         public String name() { 
    1237                 return DeliberativeProcess.NAME; 
    1238         } 
    1239  
    1240         @Override 
    1241         public void initialize(AgentModel ag) {  
    1242         } 
    1243          
     1187        public void update(AgentModel am, Event event) { 
     1188                ArrayList<IPlanningOperator> canceledActions; 
     1189                 
     1190                if(_selectedPlan != null) 
     1191                { 
     1192                        canceledActions = _selectedPlan.UpdatePlan(am); 
     1193                         
     1194                        if(_actionMonitor != null) 
     1195                        { 
     1196                                for(IPlanningOperator op : canceledActions) 
     1197                                { 
     1198                                        if(_actionMonitor.getStep().getName().equals(op.getName())) 
     1199                                        { 
     1200                                                cancelAction(am); 
     1201                                                checkLinks(am); 
     1202                                                return; 
     1203                                        } 
     1204                                } 
     1205                                 
     1206                        } 
     1207                } 
     1208                 
     1209                checkLinks(am); 
     1210                 
     1211                if(_actionMonitor != null && _actionMonitor.matchEvent(event)) { 
     1212                    if(_actionMonitor.getStep().getAgent().isGrounded() &&   
     1213                                !_actionMonitor.getStep().getAgent().toString().equals(Constants.SELF)) 
     1214                    { 
     1215                        //the agent was waiting for an action of other agent to be complete 
     1216                        //since the step of another agent may contain unbound variables, 
     1217                        //we cannot just compare the names, we need to try to unify them 
     1218                        if(Unifier.Unify(event.toStepName(),  
     1219                                        _actionMonitor.getStep().getName()) != null) 
     1220                        { 
     1221                                _actionMonitor.getStep().IncreaseProbability(am); 
     1222                                //System.out.println("Calling updateEffectsProbability (other's action: step completed)"); 
     1223                                _actionMonitor.getStep().updateEffectsProbability(am); 
     1224                        } 
     1225                        else 
     1226                        { 
     1227                                for(IActionFailureStrategy s : _actionFailureStrategies) 
     1228                                { 
     1229                                        s.perceiveActionFailure(am, _actionMonitor.getStep()); 
     1230                                } 
     1231                     
     1232                                _actionMonitor.getStep().DecreaseProbability(am); 
     1233                        } 
     1234                    } 
     1235                    else  
     1236                    { 
     1237                        for(IActionSuccessStrategy s : _actionSuccessStrategies) 
     1238                        { 
     1239                                s.perceiveActionSuccess(am, _actionMonitor.getStep()); 
     1240                        } 
     1241                        //System.out.println("Calling updateEffectsProbability (self: step completed)"); 
     1242                        _actionMonitor.getStep().updateEffectsProbability(am); 
     1243                    } 
     1244                                 
     1245                        updateProbabilities(); 
     1246                        _actionMonitor = null; 
     1247                } 
     1248        } 
     1249 
    12441250        @Override 
    12451251        public void update(AgentModel am, long time) 
     
    12471253                if(_actionMonitor != null) 
    12481254                { 
    1249                         if(_actionMonitor.expired() || !_actionMonitor.checkPreconditions(am)) 
    1250                         { 
    1251                                 AgentLogger.GetInstance().logAndPrint("Action monitor failed or expired: " + _actionMonitor.toString()); 
    1252                                 //If the action expired or failed we must check the plan links (continuous planning) 
     1255                        if(_actionMonitor.expired()) 
     1256                        { 
     1257                                AgentLogger.GetInstance().logAndPrint("Action monitor expired: " + _actionMonitor.toString()); 
     1258                                //If the action expired we must check the plan links (continuous planning) 
    12531259                                //just to make sure 
    1254                                 CheckLinks(am); 
     1260                                checkLinks(am); 
    12551261                                 
    12561262                                for(IActionFailureStrategy s : _actionFailureStrategies) 
     
    12601266                                _actionMonitor.getStep().DecreaseProbability(am); 
    12611267                                 
    1262                                 UpdateProbabilities(); 
     1268                                updateProbabilities(); 
    12631269                                 
    1264                                 cancelAction(am); 
    12651270                            _actionMonitor = null; 
    12661271                        } 
     
    12681273        } 
    12691274 
    1270  
    1271         @Override 
    1272         public IComponent createModelOfOther() { 
    1273                 return new DeliberativeProcess(_goalLibrary, _planner); 
    1274         } 
    1275  
    1276  
    1277         @Override 
    1278         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    1279                 return null; 
    1280         } 
    1281          
    1282         @Override 
    1283         public void appraisal(AgentModel am, Event e, AppraisalFrame as) { 
    1284         } 
    1285  
    1286         @Override 
    1287         public AppraisalFrame reappraisal(AgentModel am) { 
    1288                 return null; 
    1289         } 
    1290  
    1291         @Override 
    1292         public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
     1275        /** 
     1276         * Forces the recalculation of all plan's probability 
     1277         */ 
     1278        public void updateProbabilities() { 
     1279                 
     1280                Iterator<Intention> it;  
     1281                 
     1282                it = _intentions.values().iterator(); 
     1283                while (it.hasNext()) { 
     1284                        ((Intention) it.next()).UpdateProbabilities(); 
     1285                } 
    12931286        } 
    12941287} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/deliberativeLayer/EmotionalPlanner.java

    r922 r950  
    114114 
    115115import FAtiMA.Core.AgentModel; 
    116 import FAtiMA.Core.IntegrityValidator; 
    117116import FAtiMA.Core.OCCAffectDerivation.OCCAppraisalVariables; 
    118117import FAtiMA.Core.OCCAffectDerivation.OCCBaseEmotion; 
     
    131130import FAtiMA.Core.deliberativeLayer.plan.Plan; 
    132131import FAtiMA.Core.deliberativeLayer.plan.ProtectedCondition; 
    133 import FAtiMA.Core.deliberativeLayer.plan.Step; 
    134132import FAtiMA.Core.emotionalState.ActiveEmotion; 
    135133import FAtiMA.Core.emotionalState.AppraisalFrame; 
    136 import FAtiMA.Core.exceptions.UnknownSpeechActException; 
    137 import FAtiMA.Core.exceptions.UnspecifiedVariableException; 
    138134import FAtiMA.Core.util.AgentLogger; 
    139135import FAtiMA.Core.util.Constants; 
     
    152148        private static final long serialVersionUID = 1L; 
    153149         
    154         private ArrayList<Step> _actions; 
     150         
    155151        private int _variableIdentifier; 
    156152         
     
    162158         * @param es - the character's emotional state 
    163159         */ 
    164         public EmotionalPlanner(ArrayList<Step> operators) 
     160        public EmotionalPlanner() 
    165161        { 
    166162            this._variableIdentifier = 1; 
    167             //this._closedGoals = new HashMap(); 
    168             this._actions = operators; 
    169163        } 
    170164         
     
    211205                return answerUtility; 
    212206        }*/ 
    213          
    214         /** 
    215          * Checks the integrity of the Planner operators/Steps/actions. 
    216          * For instance it checks if a operator references a SpeechAct not  
    217          * defined, or if it uses a unbound variable (in effects or preconditions) 
    218          * not used in the operator's name  
    219          * @param val - the IntegrityValidator used to detect problems 
    220          * @throws UnspecifiedVariableException - thrown when the operator uses a unbound 
    221          *                                                                                variable in the effects or preconditions 
    222          *                                                                            without using the same variable in the  
    223          *                                                                            step's name 
    224          * @throws UnknownSpeechActException - thrown when the operator references a  
    225          *                                                                         SpeechAct not defined 
    226          */ 
    227         public void CheckIntegrity(IntegrityValidator val) throws UnspecifiedVariableException, UnknownSpeechActException { 
    228             ListIterator<Step> li = _actions.listIterator(); 
    229              
    230             while(li.hasNext()) { 
    231                  li.next().CheckIntegrity(val); 
    232             } 
    233         } 
    234207 
    235208         
     
    246219         *                                      Step, false - uses the steps that the received plan contains 
    247220         */ 
    248         public void FindStepFor(Intention intention, Plan p, OpenPrecondition openPrecond, boolean newStep) { 
     221        public void FindStepFor(AgentModel am, Intention intention, Plan p, OpenPrecondition openPrecond, boolean newStep) { 
    249222                ListIterator<? extends IPlanningOperator> li; 
    250223                Condition cond; 
     
    267240                 
    268241                if (newStep) 
    269                         li = _actions.listIterator(); 
     242                        li = am.getActionLibrary().getActions().listIterator(); 
    270243                else 
    271244                        li = p.getSteps().listIterator(); 
     
    356329         
    357330         
    358         /** 
    359          * Gets the planner's operators/steps/actions 
    360          * @return a list with Steps 
    361          */ 
    362         public ArrayList<Step> GetOperators() { 
    363             return _actions; 
    364         } 
    365          
    366         public void AddOperator(Step op) 
    367         { 
    368                 _actions.add(op); 
    369         } 
    370          
    371         /** 
    372          * Gets the operator that corresponds to the given name 
    373          * @param name - the name of the step to get 
    374          * @return the searched step if it is found, null otherwise 
    375          */ 
    376         public Step GetStep(String name) { 
    377                  
    378                 for(Step s : _actions) 
    379                 { 
    380                         if(s.getName().toString().equals(name)) 
    381                         { 
    382                                 return s; 
    383                         } 
    384                 } 
    385                  
    386                 return null; 
    387         } 
     331         
    388332 
    389333        /** 
     
    400344         *                       returns null 
    401345         */ 
    402         public Plan ThinkAbout(AgentModel am, Intention intention) { 
     346        public Plan ThinkAbout(AgentModel am, DeliberativeProcess dp, Intention intention) { 
    403347                Plan p; 
    404348                Plan newPlan; 
     
    441385         
    442386                prob = p.getProbability(am); 
    443                 goalProb = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, intention.getGoal()); 
     387                goalProb = dp.getProbabilityStrategy().getProbability(am, intention.getGoal()); 
    444388                if(p.getOpenPreconditions().size() == 0) 
    445389                { 
     
    682626                        //TODO talvez possa fazer isto de uma maneira mais eficiente 
    683627                        //Tries to find a step in the plan that achieves the precondition 
    684                         FindStepFor(intention, p, openPrecond, false); 
     628                        FindStepFor(am,intention, p, openPrecond, false); 
    685629                        //tries to find a new step from the available actions that achieves the precondition   
    686                         FindStepFor(intention, p, openPrecond, true); 
     630                        FindStepFor(am,intention, p, openPrecond, true); 
    687631 
    688632                } 
     
    693637                        return null; 
    694638                } 
     639                 
    695640                //the plan is complete, no flaw was removed 
    696641                else return p; 
     
    706651        public Plan DevelopPlan(AgentModel am, ActivePursuitGoal goal) 
    707652    { 
    708             Plan p = new Plan(new ArrayList<ProtectedCondition>(),am.getDeliberativeLayer().getDetectThreatStrategy(),goal.GetSuccessConditions()); 
     653                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     654                 
     655            Plan p = new Plan(new ArrayList<ProtectedCondition>(),dp.getDetectThreatStrategy(),goal.GetSuccessConditions()); 
    709656        Intention i = new Intention(am, goal); 
    710657        i.AddPlan(p); 
     
    713660        while (i.NumberOfAlternativePlans() > 0) 
    714661        { 
    715             completePlan = ThinkAbout(am, i); 
     662            completePlan = ThinkAbout(am,dp, i); 
    716663            if(completePlan != null) 
    717664            { 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/deliberativeLayer/Intention.java

    r922 r950  
    3737import java.io.Serializable; 
    3838import java.util.ArrayList; 
    39 import java.util.LinkedList; 
    4039import java.util.ListIterator; 
    41 import java.util.SortedSet; 
    4240 
    4341import FAtiMA.Core.AgentModel; 
     
    242240        public float GetProbability(AgentModel am) { 
    243241                 
     242                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
     243                 
    244244                float p; 
    245245                float p2; 
    246246                float bestProb = 0; 
    247                 float goalProb = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, _goal); 
     247                float goalProb = dp.getProbabilityStrategy().getProbability(am, _goal); 
    248248                 
    249249                for(Plan plan : _planConstruction) 
     
    372372        public void ProcessIntentionActivation(AgentModel am)  
    373373        { 
     374                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
    374375            Event e = _goal.GetActivationEvent(); 
    375             float goalConduciveness = am.getDeliberativeLayer().getUtilityStrategy().getUtility(am, _goal); 
    376             float probability = am.getDeliberativeLayer().getProbabilityStrategy().getProbability(am, _goal); 
     376             
     377            float goalConduciveness = dp.getUtilityStrategy().getUtility(am, _goal); 
     378            float probability = dp.getProbabilityStrategy().getProbability(am, _goal); 
    377379             
    378380            AgentLogger.GetInstance().logAndPrint("Adding a new Intention: " + _goal.getName().toString()); 
     
    396398        public void ProcessIntentionFailure(AgentModel am)  
    397399        {        
     400                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
    398401                //mental disengagement consists in lowering the goal's importance 
    399402                _goal.DecreaseImportanceOfFailure(am, 0.5f); 
     
    405408            AppraisalFrame af = new AppraisalFrame(e); 
    406409            af.SetAppraisalVariable(DeliberativeProcess.NAME,(short)8,OCCAppraisalVariables.GOALSTATUS.name(), OCCComponent.GOALDISCONFIRMED); 
    407             af.SetAppraisalVariable(DeliberativeProcess.NAME, (short)8,OCCAppraisalVariables.GOALCONDUCIVENESS.name(), am.getDeliberativeLayer().getUtilityStrategy().getUtility(am, _goal)); 
     410            af.SetAppraisalVariable(DeliberativeProcess.NAME, (short)8,OCCAppraisalVariables.GOALCONDUCIVENESS.name(), dp.getUtilityStrategy().getUtility(am, _goal)); 
    408411            am.updateEmotions(af); 
    409412             
     
    433436        public void ProcessIntentionSuccess(AgentModel am)  
    434437        { 
     438                DeliberativeProcess dp = (DeliberativeProcess) am.getComponent(DeliberativeProcess.NAME); 
    435439            if(!isRootIntention()) 
    436440            { 
     
    442446            AppraisalFrame af = new AppraisalFrame(e); 
    443447            af.SetAppraisalVariable(DeliberativeProcess.NAME,(short)8,OCCAppraisalVariables.GOALSTATUS.name(), OCCComponent.GOALCONFIRMED); 
    444             af.SetAppraisalVariable(DeliberativeProcess.NAME, (short)8,OCCAppraisalVariables.GOALCONDUCIVENESS.name(), am.getDeliberativeLayer().getUtilityStrategy().getUtility(am, _goal)); 
     448            af.SetAppraisalVariable(DeliberativeProcess.NAME, (short)8,OCCAppraisalVariables.GOALCONDUCIVENESS.name(), dp.getUtilityStrategy().getUtility(am, _goal)); 
    445449            am.updateEmotions(af); 
    446450                                                 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/deliberativeLayer/plan/Plan.java

    r801 r950  
    112112import FAtiMA.Core.AgentModel; 
    113113import FAtiMA.Core.conditions.Condition; 
     114import FAtiMA.Core.deliberativeLayer.ActionMonitor; 
    114115import FAtiMA.Core.deliberativeLayer.IDetectThreatStrategy; 
    115116import FAtiMA.Core.util.AgentLogger; 
     
    620621     * such continuous planning flaws. This method should be called whenever the world changes.  
    621622     */ 
    622     public void UpdatePlan(AgentModel am) 
     623    public ArrayList<IPlanningOperator> UpdatePlan(AgentModel am) 
    623624    { 
    624625        CausalLink link; 
     
    628629        Condition cond; 
    629630        IPlanningOperator op; 
     631         
     632        ArrayList<IPlanningOperator> canceledActions = new ArrayList<IPlanningOperator>();  
    630633         
    631634         
     
    651654                 
    652655                //TODO Extending a causal link to start might be causing problems with 
    653                 // the planning algorithm 
     656                // the planning algorithm (for instance, you may not want to extend a causal link to start 
     657                // because doing so will lead to a dead end, and instead you want to use another action  
    654658                op = getOperator(link.getDestination()); 
    655659                cond = op.getPrecondition(link.getCondition()); 
     
    764768                            .getDestination(), link.getCondition())); 
    765769                    linksToRemove.add(link); 
     770                     
     771                    canceledActions.add(op); 
     772                     
     773                     
    766774                } 
    767775                } 
     
    770778        //finally at the end of the second stage we must still remove 
    771779        //all the unsupported links that were found 
     780        //in this case we don't need to remove redundant steps, because 
     781        //the Start Step is never redundant, and furthermore we cannot remove it 
    772782        for(ListIterator<CausalLink> li = linksToRemove.listIterator(); li.hasNext();) 
    773783        { 
    774784                link = (CausalLink) li.next(); 
    775785                RemoveCausalLink(link); 
    776                 //in this case we don't need to remove redundant steps, because 
    777                 //the Start Step is never redundant, and furthermore we cannot remove it 
    778         } 
     786        } 
     787         
     788        return canceledActions; 
    779789    } 
    780790 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/emotionalState/EmotionalState.java

    r922 r950  
    240240                Iterator<ActiveEmotion> it; 
    241241 
    242                 long currentTime = AgentSimulationTime.GetInstance().Time();; 
    243                 if (currentTime >= _lastTime + 1000) { 
     242                long currentTime = AgentSimulationTime.GetInstance().Time(); 
     243                long deltaTime = currentTime - _lastTime; 
     244                if (deltaTime >= 1000L) { 
    244245                        _lastTime = currentTime; 
    245246 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/sensorEffector/RemoteAgent.java

    r926 r950  
    707707                String goalName = st.nextToken(); 
    708708                float importance = new Float(st.nextToken()).floatValue(); 
    709                 _agent.getDeliberativeLayer().ChangeGoalImportance(_agent, goalName,importance,type); 
     709                _agent.getDeliberativeLayer().changeGoalImportance(_agent, goalName,importance,type); 
    710710        } 
    711711         
     
    801801                        importance2 = new Float(st2.nextToken()).floatValue(); 
    802802                        try { 
    803                                 _agent.getDeliberativeLayer().AddGoal(_agent, goalName,importance,importance2); 
     803                                _agent.getDeliberativeLayer().addGoal(_agent, goalName,importance,importance2); 
    804804                        } 
    805805                        catch(Exception e) { 
     
    811811        protected void RemoveGoalPerception(String perc) 
    812812        { 
    813                 _agent.getDeliberativeLayer().RemoveGoal(perc);  
     813                _agent.getDeliberativeLayer().removeGoal(perc);  
    814814        } 
    815815         
    816816        protected void RemoveAllGoalsPerception(String perc) 
    817817        { 
    818                 _agent.getDeliberativeLayer().RemoveAllGoals(); 
     818                _agent.getDeliberativeLayer().removeAllGoals(); 
    819819        } 
    820820         
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/util/parsers/AgentLoaderHandler.java

    r896 r950  
    201201      } 
    202202                         
    203       _deliberativeLayer.AddGoal(_am, _goalName,impOfSucess,impOfFailure);  
     203      _deliberativeLayer.addGoal(_am, _goalName,impOfSucess,impOfFailure);  
    204204    } 
    205205     
  • AgentMind/branches/FAtiMA-Modular/WorldTest/src/RemoteAgent.java

    r718 r950  
    3131public class RemoteAgent extends SocketListener { 
    3232 
    33         final static int MIN_ACTION_DELAY_MS = 500; 
    34         final static int MAX_ACTION_DELAY_MS = 500; 
     33        final static int MIN_ACTION_DELAY_MS = 10000; 
     34        final static int MAX_ACTION_DELAY_MS = 10000; 
    3535        protected Random _generator;  
    3636        private ArrayList<Property> _properties; 
     
    343343                                aux2= aux2 + " " + x; 
    344344                        } 
     345                         
     346                         
    345347 
    346348                        synchronized(_ra){ 
     
    350352                        String perception = "ACTION-FINISHED " + aux; 
    351353                        synchronized(_world){ 
    352                                 _world.GetUserInterface().WriteLine(aux); 
    353354                                _world.SendPerceptionToAll(perception); 
     355                            _world.GetUserInterface().WriteLine(aux); 
    354356                        }        
     357                         
    355358                } 
    356359        } 
  • AgentMind/branches/FAtiMA-Modular/WorldTest/src/UserInterface.java

    r868 r950  
    363363     
    364364    public void actionPerformed(ActionEvent evt) { 
    365                 String perception = "ACTION-FINISHED " + inputList.getSelectedItem().toString(); 
    366                 this.WriteLine(inputList.getSelectedItem().toString()); 
    367                 _world.SendPerceptionToAll(perception); 
    368                 StringTokenizer st = new StringTokenizer(inputList.getSelectedItem().toString(), " "); 
     365        StringTokenizer st = new StringTokenizer(inputList.getSelectedItem().toString(), " "); 
    369366                if(st.countTokens() > 1) 
    370367                { 
     
    375372                        this.UpdateActionEffects(subject, ConvertToActionName(action)); 
    376373                } 
     374         
     375                String perception = "ACTION-FINISHED " + inputList.getSelectedItem().toString(); 
     376                this.WriteLine(inputList.getSelectedItem().toString()); 
     377                _world.SendPerceptionToAll(perception); 
    377378    } 
    378379     
Note: See TracChangeset for help on using the changeset viewer.