Changeset 972


Ignore:
Timestamp:
02/14/2011 10:22:04 AM (10 years ago)
Author:
joao.dias
Message:
 
Location:
AgentMind/branches/FAtiMA-Modular
Files:
1 added
13 edited

Legend:

Unmodified
Added
Removed
  • AgentMind/branches/FAtiMA-Modular/AgentLauncher/src/AgentLauncher.java

    r971 r972  
    1313import FAtiMA.DeliberativeComponent.DeliberativeComponent; 
    1414import FAtiMA.OCCAffectDerivation.OCCAffectDerivationComponent; 
    15 import FAtiMA.ReactiveComponent.ReactiveComponent; 
     15import FAtiMA.motivationalSystem.MotivationalComponent; 
    1616 
    1717public class AgentLauncher { 
     
    3737                        extraFiles.add(cultureFile); 
    3838                         
    39                         aG.addComponent(new ReactiveComponent()); 
    40                         aG.addComponent(new OCCAffectDerivationComponent()); 
    41                         aG.addComponent(new DeliberativeComponent()); 
     39                        //aG.addComponent(new ReactiveComponent()); 
     40                        //aG.addComponent(new OCCAffectDerivationComponent()); 
     41                        //aG.addComponent(new DeliberativeComponent()); 
    4242                        //aG.addComponent(new SocialRelationsComponent(extraFiles)); 
    4343                        //aG.addComponent(new MotivationalComponent(extraFiles)); 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.AdvancedMemory/src/main/java/FAtiMA/advancedMemoryComponent/AdvancedMemoryComponent.java

    r970 r972  
    8888        } 
    8989         
    90         public CompoundCue getCompoundCue() 
    91         { 
    92                 return _compoundCue; 
    93         } 
    94          
    95         public SpreadActivate getSpreadActivate() 
    96         { 
    97                 return _spreadActivate; 
    98         } 
    99          
    100         public Generalisation getGeneralisation() 
    101         { 
    102                 return _generalisation; 
    103         } 
    104          
    105         private void loadMemoryProcessesConditions(AgentModel ag){ 
    106  
    107                 AgentLogger.GetInstance().log("LOADING GeneralMemory Conditions: "); 
    108                  
    109                 ActionsLoaderHandler generalMemoryLoader = new ActionsLoaderHandler(ag); 
    110                  
    111                 try{ 
    112                         SAXParserFactory factory = SAXParserFactory.newInstance(); 
    113                         SAXParser parser = factory.newSAXParser(); 
    114                         parser.parse(new File(ConfigurationManager.getActionsFile()),generalMemoryLoader); 
    115                          
    116  
    117                 }catch(Exception e){ 
    118                         throw new RuntimeException("GeneralMemory Error on Loading the Actions XML File:" + e); 
    119                 } 
    120         } 
    121          
    122         /** 
    123          * Extract known information 
    124          * @param  
    125          * @return 
    126          * added by Meiyii 19/11/09 
    127          */ 
    128         private ArrayList<String> extractKnownInfo(String known) 
    129         { 
    130                 ArrayList<String> knownInfo = new ArrayList<String>(); 
    131                          
    132                 StringTokenizer st = new StringTokenizer(known, "*"); 
    133                 while(st.hasMoreTokens()) 
    134                 { 
    135                         String knownStr = st.nextToken(); 
    136                         knownInfo.add(knownStr); 
    137                         System.out.println("Known String " + knownStr); 
    138                 } 
    139                 return knownInfo; 
    140         } 
    141          
    14290        /** 
    14391         * Extract generalisation attributes 
     
    159107                //this._gmPanel.PanelAttributes(_gAttributes); 
    160108        } 
    161  
    162         @Override 
    163         public String name() { 
    164                 return AdvancedMemoryComponent.NAME; 
     109         
     110        /** 
     111         * Extract known information 
     112         * @param  
     113         * @return 
     114         * added by Meiyii 19/11/09 
     115         */ 
     116        private ArrayList<String> extractKnownInfo(String known) 
     117        { 
     118                ArrayList<String> knownInfo = new ArrayList<String>(); 
     119                         
     120                StringTokenizer st = new StringTokenizer(known, "*"); 
     121                while(st.hasMoreTokens()) 
     122                { 
     123                        String knownStr = st.nextToken(); 
     124                        knownInfo.add(knownStr); 
     125                        System.out.println("Known String " + knownStr); 
     126                } 
     127                return knownInfo; 
     128        } 
     129         
     130        private void loadMemoryProcessesConditions(AgentModel ag){ 
     131 
     132                AgentLogger.GetInstance().log("LOADING GeneralMemory Conditions: "); 
     133                 
     134                ActionsLoaderHandler generalMemoryLoader = new ActionsLoaderHandler(ag); 
     135                 
     136                try{ 
     137                        SAXParserFactory factory = SAXParserFactory.newInstance(); 
     138                        SAXParser parser = factory.newSAXParser(); 
     139                        parser.parse(new File(ConfigurationManager.getActionsFile()),generalMemoryLoader); 
     140                         
     141 
     142                }catch(Exception e){ 
     143                        throw new RuntimeException("GeneralMemory Error on Loading the Actions XML File:" + e); 
     144                } 
     145        } 
     146         
     147        @Override 
     148        public void appraisal(AgentModel am, Event e, AppraisalFrame af) { 
     149                 
     150                //appraisal from memory 
     151                ActionDetail ad = new ActionDetail(0,e.GetSubject(), 
     152                                        e.GetAction(),  
     153                                        e.GetTarget(), 
     154                                        e.GetParameters(),null,null,null); 
     155                         
     156                _compoundCue.Match(ad,am.getMemory().getEpisodicMemory()); 
     157                         
     158                ActionDetail result = _compoundCue.getStrongestResult(); 
     159                //float eval = _compoundCue.getEvaluation(); 
     160                if(result != null) 
     161                { 
     162                        float desirability = result.getDesirability(); 
     163                        if(desirability != 0) 
     164                        { 
     165                                af.SetAppraisalVariable(AdvancedMemoryComponent.NAME, (short)3, OCCAppraisalVariables.DESIRABILITY.name(), desirability); 
     166                        }        
     167                } 
     168        } 
     169         
     170        @Override 
     171        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     172                 
     173                this._gmPanel = new GeneralMemoryPanel(this); 
     174                return this._gmPanel; 
     175        } 
     176         
     177        @Override 
     178        public String[] getComponentDependencies() { 
     179                String[] dependencies = {}; 
     180                return dependencies; 
     181        } 
     182 
     183        public CompoundCue getCompoundCue() 
     184        { 
     185                return _compoundCue; 
     186        } 
     187 
     188        public Generalisation getGeneralisation() 
     189        { 
     190                return _generalisation; 
     191        } 
     192 
     193        public SpreadActivate getSpreadActivate() 
     194        { 
     195                return _spreadActivate; 
    165196        } 
    166197 
     
    172203 
    173204        @Override 
     205        public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
     206        } 
     207 
     208        @Override 
     209        public String name() { 
     210                return AdvancedMemoryComponent.NAME; 
     211        } 
     212 
     213        @Override 
     214        public void processExternalRequest(AgentModel am, String msgType, String perception) { 
     215                 
     216                StringTokenizer st; 
     217         
     218            if(msgType.equals(SA_MEMORY)) 
     219                { 
     220                        st = new StringTokenizer(perception, "$"); 
     221                        String question = st.nextToken(); 
     222                        String known = ""; 
     223                        while(st.hasMoreTokens()) 
     224                        { 
     225                                known = known + st.nextToken(); 
     226                        }                                        
     227                        System.out.println("question " + question); 
     228                        ArrayList<String> knownInfo = extractKnownInfo(known); 
     229                        _spreadActivate.Spread(question, knownInfo, _memory.getEpisodicMemory()); 
     230                         
     231                         
     232                        Hashtable<String, Integer> saResult = _spreadActivate.getSAResults(); 
     233                         
     234                        for(String result : saResult.keySet()) 
     235                        { 
     236                                System.out.println(question + " " + result + " frequency " + saResult.get(result)); 
     237                        } 
     238                         
     239                        _commonalities.eventCommonalities(_spreadActivate.getDetails()); 
     240                        Hashtable<ArrayList<Integer>,Hashtable<String, String>> gResult = _commonalities.getMatch(); 
     241                 
     242                        for(ArrayList<Integer> result : gResult.keySet()) 
     243                        { 
     244                                System.out.println("id " + result); 
     245                                Hashtable<String, String> match = gResult.get(result); 
     246                                 
     247                                for(String matchingValues : match.keySet()) 
     248                                { 
     249                                        System.out.println("match in Remote Agent " + matchingValues); 
     250                                } 
     251                        } 
     252                         
     253                        System.out.println("\n\n"); 
     254                } 
     255                else if(msgType.equals(CC_MEMORY)) 
     256                { 
     257                        int index = Math.min(8, (int) (Math.random()*10)); 
     258                        ActionDetail event = _memory.getEpisodicMemory().getDetails().get(index); 
     259                        _compoundCue.Match(event, _memory.getEpisodicMemory()); 
     260                        System.out.println("\nEvent ID to match on " + event.getID()); 
     261                         
     262                        Hashtable<Integer, Float>  results = _compoundCue.getCCEvaluations(); 
     263                        for(Integer id: results.keySet()) 
     264                        { 
     265                                System.out.println("ID " + id + " evaluation " + results.get(id)); 
     266                        } 
     267                        ActionDetail ad = _compoundCue.getStrongestResult(); 
     268                        System.out.println("max ID " + ad.getID()); 
     269                        System.out.println("\n\n"); 
     270                } 
     271                else if(msgType.equals(G_MEMORY)) 
     272                { 
     273                        extractGAttributes(perception); 
     274                         
     275                        //Performs generalisation and update the GeneralMemory with frequent item sets 
     276                        _generalisation.generalise(_gAttributes, _memory.getEpisodicMemory());   
     277                         
     278                        ArrayList<GER> gers = _generalisation.getAllGERs(); 
     279                        for (GER ger : gers) 
     280                        { 
     281                                System.out.println("GER : " + ger.toString()); 
     282                        } 
     283                } 
     284                else if(msgType.equals(SAVE_ADV_MEMORY)) 
     285                { 
     286                        _gerWriter.outputGERtoXML(_memory.getSaveDirectory() + ADV_MEMORY_FILENAME); 
     287                } 
     288                else if(msgType.equals(LOAD_ADV_MEMORY)) 
     289                { 
     290                        try{ 
     291                                AgentLogger.GetInstance().log("LOADING AdvancedMemory Content: " + _memory.getSaveDirectory() + ADV_MEMORY_FILENAME); 
     292                                AdvancedMemoryHandler advMemoryHandler = new AdvancedMemoryHandler(this); 
     293                         
     294                                SAXParserFactory factory = SAXParserFactory.newInstance(); 
     295                                SAXParser parser = factory.newSAXParser(); 
     296                                parser.parse(new File(_memory.getSaveDirectory() + ADV_MEMORY_FILENAME), advMemoryHandler); 
     297                        } 
     298                        catch (Exception ex) { 
     299                                ex.printStackTrace(); 
     300                        } 
     301                }                        
     302        } 
     303 
     304        @Override 
     305        public AppraisalFrame reappraisal(AgentModel am) { 
     306                return null; 
     307        } 
     308 
     309        @Override 
    174310        public void reset() { 
    175311                // TODO Auto-generated method stub 
     312        } 
     313 
     314        @Override 
     315        public void update(AgentModel am, Event e) { 
    176316        } 
    177317 
     
    192332                }*/ 
    193333        } 
    194  
    195         @Override 
    196         public void update(AgentModel am, Event e) { 
    197         } 
    198  
    199         @Override 
    200         public void appraisal(AgentModel am, Event e, AppraisalFrame af) { 
    201                  
    202                 //appraisal from memory 
    203                 ActionDetail ad = new ActionDetail(0,e.GetSubject(), 
    204                                         e.GetAction(),  
    205                                         e.GetTarget(), 
    206                                         e.GetParameters(),null,null,null); 
    207                          
    208                 _compoundCue.Match(ad,am.getMemory().getEpisodicMemory()); 
    209                          
    210                 ActionDetail result = _compoundCue.getStrongestResult(); 
    211                 //float eval = _compoundCue.getEvaluation(); 
    212                 if(result != null) 
    213                 { 
    214                         float desirability = result.getDesirability(); 
    215                         if(desirability != 0) 
    216                         { 
    217                                 af.SetAppraisalVariable(AdvancedMemoryComponent.NAME, (short)3, OCCAppraisalVariables.DESIRABILITY.name(), desirability); 
    218                         }        
    219                 } 
    220         } 
    221  
    222         @Override 
    223         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    224                  
    225                 this._gmPanel = new GeneralMemoryPanel(this); 
    226                 return this._gmPanel; 
    227         } 
    228  
    229         @Override 
    230         public void processExternalRequest(AgentModel am, String msgType, String perception) { 
    231                  
    232                 StringTokenizer st; 
    233          
    234             if(msgType.equals(SA_MEMORY)) 
    235                 { 
    236                         st = new StringTokenizer(perception, "$"); 
    237                         String question = st.nextToken(); 
    238                         String known = ""; 
    239                         while(st.hasMoreTokens()) 
    240                         { 
    241                                 known = known + st.nextToken(); 
    242                         }                                        
    243                         System.out.println("question " + question); 
    244                         ArrayList<String> knownInfo = extractKnownInfo(known); 
    245                         _spreadActivate.Spread(question, knownInfo, _memory.getEpisodicMemory()); 
    246                          
    247                          
    248                         Hashtable<String, Integer> saResult = _spreadActivate.getSAResults(); 
    249                          
    250                         for(String result : saResult.keySet()) 
    251                         { 
    252                                 System.out.println(question + " " + result + " frequency " + saResult.get(result)); 
    253                         } 
    254                          
    255                         _commonalities.eventCommonalities(_spreadActivate.getDetails()); 
    256                         Hashtable<ArrayList<Integer>,Hashtable<String, String>> gResult = _commonalities.getMatch(); 
    257                  
    258                         for(ArrayList<Integer> result : gResult.keySet()) 
    259                         { 
    260                                 System.out.println("id " + result); 
    261                                 Hashtable<String, String> match = gResult.get(result); 
    262                                  
    263                                 for(String matchingValues : match.keySet()) 
    264                                 { 
    265                                         System.out.println("match in Remote Agent " + matchingValues); 
    266                                 } 
    267                         } 
    268                          
    269                         System.out.println("\n\n"); 
    270                 } 
    271                 else if(msgType.equals(CC_MEMORY)) 
    272                 { 
    273                         int index = Math.min(8, (int) (Math.random()*10)); 
    274                         ActionDetail event = _memory.getEpisodicMemory().getDetails().get(index); 
    275                         _compoundCue.Match(event, _memory.getEpisodicMemory()); 
    276                         System.out.println("\nEvent ID to match on " + event.getID()); 
    277                          
    278                         Hashtable<Integer, Float>  results = _compoundCue.getCCEvaluations(); 
    279                         for(Integer id: results.keySet()) 
    280                         { 
    281                                 System.out.println("ID " + id + " evaluation " + results.get(id)); 
    282                         } 
    283                         ActionDetail ad = _compoundCue.getStrongestResult(); 
    284                         System.out.println("max ID " + ad.getID()); 
    285                         System.out.println("\n\n"); 
    286                 } 
    287                 else if(msgType.equals(G_MEMORY)) 
    288                 { 
    289                         extractGAttributes(perception); 
    290                          
    291                         //Performs generalisation and update the GeneralMemory with frequent item sets 
    292                         _generalisation.generalise(_gAttributes, _memory.getEpisodicMemory());   
    293                          
    294                         ArrayList<GER> gers = _generalisation.getAllGERs(); 
    295                         for (GER ger : gers) 
    296                         { 
    297                                 System.out.println("GER : " + ger.toString()); 
    298                         } 
    299                 } 
    300                 else if(msgType.equals(SAVE_ADV_MEMORY)) 
    301                 { 
    302                         _gerWriter.outputGERtoXML(_memory.getSaveDirectory() + ADV_MEMORY_FILENAME); 
    303                 } 
    304                 else if(msgType.equals(LOAD_ADV_MEMORY)) 
    305                 { 
    306                         try{ 
    307                                 AgentLogger.GetInstance().log("LOADING AdvancedMemory Content: " + _memory.getSaveDirectory() + ADV_MEMORY_FILENAME); 
    308                                 AdvancedMemoryHandler advMemoryHandler = new AdvancedMemoryHandler(this); 
    309                          
    310                                 SAXParserFactory factory = SAXParserFactory.newInstance(); 
    311                                 SAXParser parser = factory.newSAXParser(); 
    312                                 parser.parse(new File(_memory.getSaveDirectory() + ADV_MEMORY_FILENAME), advMemoryHandler); 
    313                         } 
    314                         catch (Exception ex) { 
    315                                 ex.printStackTrace(); 
    316                         } 
    317                 }                        
    318         } 
    319  
    320         @Override 
    321         public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
    322         } 
    323  
    324         @Override 
    325         public AppraisalFrame reappraisal(AgentModel am) { 
    326                 return null; 
    327         } 
    328334} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.DeliberativeComponent/src/FAtiMA/DeliberativeComponent/DeliberativeComponent.java

    r971 r972  
    252252        } 
    253253         
     254        private void AddGoalsRequest(AgentModel am, String perc) 
     255        { 
     256                String goalDescription; 
     257                String goalName; 
     258                float importance; 
     259                float importance2; 
     260                StringTokenizer st2; 
     261                StringTokenizer st = new StringTokenizer(perc," "); 
     262                 
     263                while(st.hasMoreTokens()) { 
     264                        goalDescription = st.nextToken(); 
     265                        st2 = new StringTokenizer(goalDescription,"|"); 
     266                        goalName = st2.nextToken(); 
     267                        importance = new Float(st2.nextToken()).floatValue(); 
     268                        importance2 = new Float(st2.nextToken()).floatValue(); 
     269                        try { 
     270                                addGoal(am, goalName,importance,importance2); 
     271                        } 
     272                        catch(Exception e) { 
     273                                e.printStackTrace(); 
     274                        } 
     275                } 
     276        } 
     277         
    254278        private void cancelAction(AgentModel am) 
    255279        { 
     
    687711                } 
    688712        } 
    689          
     713                 
    690714        public void addOptionsStrategy(IOptionsStrategy strategy) 
    691715        { 
    692716                _optionStrategies.add(strategy); 
    693717        } 
    694                  
     718         
     719         
    695720        /** 
    696721         * Adds a ProtectionConstraint to the DeliberativeLayer. The planner will detect 
     
    704729                _protectionConstraints.add(cond); 
    705730        } 
    706          
    707731         
    708732        public void addSubIntention(AgentModel am, Intention mainIntention, ActivePursuitGoal goal) 
     
    907931        } 
    908932         
     933        @Override 
     934        public String[] getComponentDependencies() { 
     935                String[] dependencies = {}; 
     936                return dependencies; 
     937        } 
     938 
    909939        /** 
    910940         * Gets the agent's emotional planner used in the deliberative reasoning process 
     
    915945        } 
    916946         
     947         
     948         
    917949        public float getExpectedUtility(AgentModel am, ActivePursuitGoal g) { 
    918950                return _UStrategy.getUtility(am, g) * _PStrategy.getProbability(am, g); 
    919951        } 
    920  
     952         
    921953        public float getExpectedUtility(AgentModel am, Intention i) { 
    922954                return _UStrategy.getUtility(am, i.getGoal()) * _PStrategy.getProbability(am, i); 
    923955        } 
    924          
    925          
    926956         
    927957        public IExpectedUtilityStrategy getExpectedUtilityStrategy() 
     
    9991029        public void lookAtPerception(AgentCore ag, String subject, String target) { 
    10001030        } 
    1001          
     1031 
     1032 
    10021033        @Override 
    10031034        public String name() { 
     
    10561087        } 
    10571088 
    1058  
     1089        @Override 
     1090        public void processExternalRequest(AgentModel am, String type, String perception) { 
     1091                 
     1092                StringTokenizer st; 
     1093                 
     1094                 
     1095                if(type.equals(CHANGE_IMPORTANCE_SUCCESS)  
     1096                                || type.equals(CHANGE_IMPORTANCE_FAILURE)) 
     1097                { 
     1098                        st = new StringTokenizer(perception," "); 
     1099                        String goalName = st.nextToken(); 
     1100                        float importance = new Float(st.nextToken()).floatValue(); 
     1101                        changeGoalImportance(am, goalName,importance,type); 
     1102                } 
     1103                else if(type.equals(ADD_GOALS)) { 
     1104                        AddGoalsRequest(am, perception); 
     1105                } 
     1106                else if(type.equals(REMOVE_GOAL)) { 
     1107                        removeGoal(perception); 
     1108                } 
     1109                else if (type.equals(REMOVE_ALL_GOALS)) { 
     1110                        removeAllGoals(); 
     1111                } 
     1112        } 
     1113         
    10591114        @Override 
    10601115        public void propertyChangedPerception(String ToM, Name propertyName,String value) { 
    10611116        } 
    1062          
     1117 
     1118 
    10631119        @Override 
    10641120        public AppraisalFrame reappraisal(AgentModel am) { 
    10651121                return null; 
    10661122        } 
     1123 
    10671124 
    10681125        /** 
     
    10991156        } 
    11001157 
    1101  
    11021158        public void removeIntention(Intention i) 
    11031159        { 
     
    11171173                } 
    11181174        } 
    1119  
    11201175 
    11211176        /** 
     
    11321187                _selectedActionEmotion = null; 
    11331188        } 
    1134          
     1189 
    11351190        public void setExpectedUtilityStrategy(IExpectedUtilityStrategy strategy) 
    11361191        { 
     
    12961351                } 
    12971352        } 
    1298  
     1353         
    12991354        @Override 
    13001355        public void update(AgentModel am, long time) 
     
    13211376                } 
    13221377        } 
    1323  
     1378         
    13241379        /** 
    13251380         * Forces the recalculation of all plan's probability 
     
    13341389                } 
    13351390        } 
    1336  
    1337         @Override 
    1338         public void processExternalRequest(AgentModel am, String type, String perception) { 
    1339                  
    1340                 StringTokenizer st; 
    1341                  
    1342                  
    1343                 if(type.equals(CHANGE_IMPORTANCE_SUCCESS)  
    1344                                 || type.equals(CHANGE_IMPORTANCE_FAILURE)) 
    1345                 { 
    1346                         st = new StringTokenizer(perception," "); 
    1347                         String goalName = st.nextToken(); 
    1348                         float importance = new Float(st.nextToken()).floatValue(); 
    1349                         changeGoalImportance(am, goalName,importance,type); 
    1350                 } 
    1351                 else if(type.equals(ADD_GOALS)) { 
    1352                         AddGoalsRequest(am, perception); 
    1353                 } 
    1354                 else if(type.equals(REMOVE_GOAL)) { 
    1355                         removeGoal(perception); 
    1356                 } 
    1357                 else if (type.equals(REMOVE_ALL_GOALS)) { 
    1358                         removeAllGoals(); 
    1359                 } 
    1360         } 
    1361          
    1362         private void AddGoalsRequest(AgentModel am, String perc) 
    1363         { 
    1364                 String goalDescription; 
    1365                 String goalName; 
    1366                 float importance; 
    1367                 float importance2; 
    1368                 StringTokenizer st2; 
    1369                 StringTokenizer st = new StringTokenizer(perc," "); 
    1370                  
    1371                 while(st.hasMoreTokens()) { 
    1372                         goalDescription = st.nextToken(); 
    1373                         st2 = new StringTokenizer(goalDescription,"|"); 
    1374                         goalName = st2.nextToken(); 
    1375                         importance = new Float(st2.nextToken()).floatValue(); 
    1376                         importance2 = new Float(st2.nextToken()).floatValue(); 
    1377                         try { 
    1378                                 addGoal(am, goalName,importance,importance2); 
    1379                         } 
    1380                         catch(Exception e) { 
    1381                                 e.printStackTrace(); 
    1382                         } 
    1383                 } 
    1384         } 
    13851391} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.EmotionalIntelligence/src/FAtiMA/emotionalIntelligence/EmotionalIntelligence.java

    r961 r972  
    1515import FAtiMA.ReactiveComponent.Action; 
    1616import FAtiMA.ReactiveComponent.ReactiveComponent; 
     17import FAtiMA.advancedMemoryComponent.AdvancedMemoryComponent; 
    1718 
    1819public class EmotionalIntelligence implements IComponent { 
     
    2627                _parsingFiles = new ArrayList<String>(); 
    2728                _parsingFiles.addAll(extraFiles); 
    28         } 
    29  
    30         @Override 
    31         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    32                 return null; 
    33         } 
    34  
    35         @Override 
    36         public void initialize(AgentModel am) { 
    37                  
    38                 ReactiveComponent reactiveComponent = (ReactiveComponent) am.getComponent(ReactiveComponent.NAME); 
    39  
    40                 ArrayList<Step> occRules = OCCAppraisalRules.GenerateOCCAppraisalRules(am); 
    41                 for(Step s : occRules) 
    42                 { 
    43                         am.getActionLibrary().addAction(s); 
    44                 } 
    45                  
    46                 for(Action at: reactiveComponent.getActionTendencies().getActions()) 
    47                 { 
    48                         am.getActionLibrary().addAction(ActionTendencyOperatorFactory.CreateATOperator(am, at)); 
    49                 } 
    50                  
    51                 LoadOperators(am); 
    5229        } 
    5330 
     
    7249 
    7350        @Override 
    74         public String name() { 
    75                 return EmotionalIntelligence.NAME;  
     51        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     52                return null; 
    7653        } 
    7754 
    7855        @Override 
    79         public void reset() { 
     56        public String[] getComponentDependencies() { 
     57                String[] dependencies = {ReactiveComponent.NAME,AdvancedMemoryComponent.NAME}; 
     58                return dependencies; 
     59        } 
     60 
     61        @Override 
     62        public void initialize(AgentModel am) { 
     63                 
     64                ReactiveComponent reactiveComponent = (ReactiveComponent) am.getComponent(ReactiveComponent.NAME); 
     65 
     66                ArrayList<Step> occRules = OCCAppraisalRules.GenerateOCCAppraisalRules(am); 
     67                for(Step s : occRules) 
     68                { 
     69                        am.getActionLibrary().addAction(s); 
     70                } 
     71                 
     72                for(Action at: reactiveComponent.getActionTendencies().getActions()) 
     73                { 
     74                        am.getActionLibrary().addAction(ActionTendencyOperatorFactory.CreateATOperator(am, at)); 
     75                } 
     76                 
     77                LoadOperators(am); 
     78        } 
     79 
     80        @Override 
     81        public String name() { 
     82                return EmotionalIntelligence.NAME;  
    8083        } 
    8184         
    8285         
    8386        @Override 
    84         public void update(AgentModel am, long time) { 
    85                 // TODO Auto-generated method stub 
     87        public void reset() { 
    8688        } 
    8789         
     
    9092        { 
    9193        } 
     94         
     95        @Override 
     96        public void update(AgentModel am, long time) { 
     97                // TODO Auto-generated method stub 
     98        } 
    9299} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.Emotivector/src/FAtiMA/emotivector/EmotivectorComponent.java

    r929 r972  
    2727        private float expectedValue; 
    2828         
    29         @Override 
    30         public String name() { 
    31                 return "EmotivectorComponent"; 
    32         } 
    33  
    34         @Override 
    35         public void initialize(AgentModel am) { 
    36                 expectedValue = 0;       
    37         } 
    38  
    39  
    40         @Override 
    41         public void appraisal(AgentModel am, Event e, AppraisalFrame af) { 
    42                 float sensedValue = 0; 
    43                  
    44                 //determines if the event perceived is a move 
    45                 if(isMove(e)){ 
    46                         if(e.GetAction().equalsIgnoreCase("medium-move")){ 
    47                                 sensedValue = MEDIUM_MOVE_VALUE; 
    48                         } 
    49                         if(e.GetAction().equalsIgnoreCase("bad-move")){ 
    50                                 sensedValue = BAD_MOVE_VALUE; 
    51                         } 
    52                         if(e.GetAction().equalsIgnoreCase("good-move")){ 
    53                                 sensedValue = GOOD_MOVE_VALUE; 
    54                         } 
    55                          
    56                         af.SetAppraisalVariable(this.name(),EMOTIVECTOR_WEIGHT, AppraisalVariables.SENSED_VALUE.name(), sensedValue); 
    57                         af.SetAppraisalVariable(this.name(),EMOTIVECTOR_WEIGHT, AppraisalVariables.EXPECTED_VALUE.name(), this.expectedValue); 
    58  
    59                         //update the expectedValue using a moving average: 
    60                         this.expectedValue = ALPHA * sensedValue + (1 - ALPHA) * this.expectedValue; 
    61                 }        
    62         } 
    63  
    64         private boolean isMove(Event e) { 
    65                 String actionName = e.GetAction(); 
    66                  
    67                 if(actionName.equalsIgnoreCase("medium-move") ||  
    68                         actionName.equalsIgnoreCase("good-move") || 
    69                           actionName.equalsIgnoreCase("bad-move")){ 
    70                         return true; 
    71                 } 
    72                 return false; 
    73         } 
    74          
    75          
    76         @Override 
    77         public ArrayList<BaseEmotion> affectDerivation(AgentModel am, 
    78                         AppraisalFrame af) { 
    79          
    80                 ArrayList<BaseEmotion> result = new ArrayList<BaseEmotion>(); 
    81                  
    82                 float sv, ev, mismatch; 
    83                 BaseEmotion bE = null; 
    84                  
    85                          
    86                 if(af.containsAppraisalVariable(AppraisalVariables.SENSED_VALUE.name()) && af.containsAppraisalVariable(AppraisalVariables.EXPECTED_VALUE.name())){ 
    87                  
    88                         ArrayList<String> appraisalVariables = new ArrayList<String>(); 
    89                         appraisalVariables.add(AppraisalVariables.SENSED_VALUE.name()); 
    90                         appraisalVariables.add(AppraisalVariables.EXPECTED_VALUE.name()); 
    91                          
    92                         sv = af.getAppraisalVariable(AppraisalVariables.SENSED_VALUE.name()); 
    93                         ev = af.getAppraisalVariable(AppraisalVariables.EXPECTED_VALUE.name()); 
    94                  
    95                         mismatch = sv - ev; 
    96                  
    97                         EmotivectorSensationType emotionType = determineSensationType(ev, mismatch); 
    98                          
    99                         //add the emotion to the emotional state of the agent 
    100                         if(emotionType!=EmotivectorSensationType.NEUTRAL){ 
    101                                 result.add(new EmotivectorSensation(emotionType, af.getEvent())); 
    102                         } 
    103                 } 
    104          
    105                 return result; 
    106         } 
    107          
    10829        private EmotivectorSensationType determineSensationType(float ev, float mismatch){ 
    10930                //expected punishement 
     
    15778        } 
    15879 
    159          
     80        private boolean isMove(Event e) { 
     81                String actionName = e.GetAction(); 
     82                 
     83                if(actionName.equalsIgnoreCase("medium-move") ||  
     84                        actionName.equalsIgnoreCase("good-move") || 
     85                          actionName.equalsIgnoreCase("bad-move")){ 
     86                        return true; 
     87                } 
     88                return false; 
     89        } 
     90 
     91 
     92        @Override 
     93        public ArrayList<BaseEmotion> affectDerivation(AgentModel am, 
     94                        AppraisalFrame af) { 
     95         
     96                ArrayList<BaseEmotion> result = new ArrayList<BaseEmotion>(); 
     97                 
     98                float sv, ev, mismatch; 
     99                BaseEmotion bE = null; 
     100                 
     101                         
     102                if(af.containsAppraisalVariable(AppraisalVariables.SENSED_VALUE.name()) && af.containsAppraisalVariable(AppraisalVariables.EXPECTED_VALUE.name())){ 
     103                 
     104                        ArrayList<String> appraisalVariables = new ArrayList<String>(); 
     105                        appraisalVariables.add(AppraisalVariables.SENSED_VALUE.name()); 
     106                        appraisalVariables.add(AppraisalVariables.EXPECTED_VALUE.name()); 
     107                         
     108                        sv = af.getAppraisalVariable(AppraisalVariables.SENSED_VALUE.name()); 
     109                        ev = af.getAppraisalVariable(AppraisalVariables.EXPECTED_VALUE.name()); 
     110                 
     111                        mismatch = sv - ev; 
     112                 
     113                        EmotivectorSensationType emotionType = determineSensationType(ev, mismatch); 
     114                         
     115                        //add the emotion to the emotional state of the agent 
     116                        if(emotionType!=EmotivectorSensationType.NEUTRAL){ 
     117                                result.add(new EmotivectorSensation(emotionType, af.getEvent())); 
     118                        } 
     119                } 
     120         
     121                return result; 
     122        } 
     123 
     124        @Override 
     125        public void appraisal(AgentModel am, Event e, AppraisalFrame af) { 
     126                float sensedValue = 0; 
     127                 
     128                //determines if the event perceived is a move 
     129                if(isMove(e)){ 
     130                        if(e.GetAction().equalsIgnoreCase("medium-move")){ 
     131                                sensedValue = MEDIUM_MOVE_VALUE; 
     132                        } 
     133                        if(e.GetAction().equalsIgnoreCase("bad-move")){ 
     134                                sensedValue = BAD_MOVE_VALUE; 
     135                        } 
     136                        if(e.GetAction().equalsIgnoreCase("good-move")){ 
     137                                sensedValue = GOOD_MOVE_VALUE; 
     138                        } 
     139                         
     140                        af.SetAppraisalVariable(this.name(),EMOTIVECTOR_WEIGHT, AppraisalVariables.SENSED_VALUE.name(), sensedValue); 
     141                        af.SetAppraisalVariable(this.name(),EMOTIVECTOR_WEIGHT, AppraisalVariables.EXPECTED_VALUE.name(), this.expectedValue); 
     142 
     143                        //update the expectedValue using a moving average: 
     144                        this.expectedValue = ALPHA * sensedValue + (1 - ALPHA) * this.expectedValue; 
     145                }        
     146        } 
     147         
     148         
     149        @Override 
     150        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     151                // TODO Auto-generated method stub 
     152                return null; 
     153        } 
     154         
     155        @Override 
     156        public String[] getComponentDependencies() { 
     157                String[] dependencies = {}; 
     158                return dependencies; 
     159        } 
     160 
     161         
     162        @Override 
     163        public void initialize(AgentModel am) { 
     164                expectedValue = 0;       
     165        } 
     166 
     167        @Override 
     168        public void inverseAffectDerivation(AgentModel am, BaseEmotion em, 
     169                        AppraisalFrame af) { 
     170                // TODO Auto-generated method stub 
     171                 
     172        } 
     173 
     174        @Override 
     175        public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
     176                // TODO Auto-generated method stub 
     177                 
     178        } 
     179 
     180        @Override 
     181        public String name() { 
     182                return "EmotivectorComponent"; 
     183        } 
     184         
     185        @Override 
     186        public AppraisalFrame reappraisal(AgentModel am) { 
     187                return null; 
     188                // TODO Auto-generated method stub 
     189        } 
     190 
    160191        @Override 
    161192        public void reset() { 
     
    163194        } 
    164195 
     196 
     197        @Override 
     198        public void update(AgentModel am, Event e) { 
     199                // TODO Auto-generated method stub 
     200                 
     201        } 
     202 
    165203        @Override 
    166204        public void update(AgentModel am, long time) { 
     
    168206        } 
    169207 
    170         @Override 
    171         public void update(AgentModel am, Event e) { 
    172                 // TODO Auto-generated method stub 
    173                  
    174         } 
    175  
    176         @Override 
    177         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    178                 // TODO Auto-generated method stub 
    179                 return null; 
    180         } 
    181          
    182         @Override 
    183         public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
    184                 // TODO Auto-generated method stub 
    185                  
    186         } 
    187  
    188         @Override 
    189         public AppraisalFrame reappraisal(AgentModel am) { 
    190                 return null; 
    191                 // TODO Auto-generated method stub 
    192         } 
    193  
    194  
    195         @Override 
    196         public void inverseAffectDerivation(AgentModel am, BaseEmotion em, 
    197                         AppraisalFrame af) { 
    198                 // TODO Auto-generated method stub 
    199                  
    200         } 
    201  
    202          
    203  
    204208} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.MotivationalSystem/src/FAtiMA/motivationalSystem/MotivationalComponent.java

    r970 r972  
    5858 
    5959         
    60         protected Motivator[]  _motivators; 
    61          
    62         //protected Hashtable<String,Motivator[]> _otherAgentsMotivators; 
    63         protected long _lastTime; 
    64         protected int _goalTried; 
    65         protected int _goalSucceeded; 
    66          
    67         protected HashMap<String,Float> _appraisals; 
    68         protected HashMap<String,ExpectedGoalEffectsOnDrives> _goalEffectsOnDrives; 
    69         protected HashMap<String,ActionEffectsOnDrives> _actionEffectsOnDrives; 
    70          
    71         private ArrayList<String> _parsingFiles; 
    72  
    7360        public static double determineQuadraticNeedVariation(float currentLevel, float deviation){ 
    7461                double result = 0; 
     
    8774                return result; 
    8875        } 
     76         
     77        protected Motivator[]  _motivators; 
     78        //protected Hashtable<String,Motivator[]> _otherAgentsMotivators; 
     79        protected long _lastTime; 
     80        protected int _goalTried; 
     81         
     82        protected int _goalSucceeded; 
     83        protected HashMap<String,Float> _appraisals; 
     84        protected HashMap<String,ExpectedGoalEffectsOnDrives> _goalEffectsOnDrives; 
     85         
     86        protected HashMap<String,ActionEffectsOnDrives> _actionEffectsOnDrives; 
     87 
     88        private ArrayList<String> _parsingFiles; 
    8989 
    9090 
     
    109109         
    110110         
     111        private void LoadNeeds(AgentModel am) 
     112        { 
     113                AgentLogger.GetInstance().log("LOADING Needs: "); 
     114                NeedsLoaderHandler needsLoader = new NeedsLoaderHandler(am,this); 
     115                 
     116                try{ 
     117                        SAXParserFactory factory = SAXParserFactory.newInstance(); 
     118                        SAXParser parser = factory.newSAXParser(); 
     119                         
     120                        for(String file : _parsingFiles) 
     121                        { 
     122                                parser.parse(new File(file), needsLoader); 
     123                        }        
     124 
     125                }catch(Exception e){ 
     126                        throw new RuntimeException("Error on Loading Needs from XML Files:" + e); 
     127                } 
     128        } 
     129         
     130        private float newCompetence(boolean succeed) 
     131        { 
     132                float alpha = 0.25f; 
     133                int value = 0; 
     134                float newCompetence; 
     135                if(succeed) 
     136                { 
     137                        value = 10; 
     138                } 
     139                 
     140                Motivator competenceM = _motivators[MotivatorType.COMPETENCE]; 
     141                 
     142                newCompetence = alpha * value + (1 - alpha) * competenceM.GetIntensity(); 
     143                 
     144                if(newCompetence < 1) 
     145                { 
     146                        newCompetence = 1; 
     147                } 
     148                 
     149                return newCompetence; 
     150        } 
     151         
     152        public void addActionEffectsOnDrive(String action, String driveName, Symbol target, float value) 
     153        { 
     154                ActionEffectsOnDrives effects; 
     155                if(!_actionEffectsOnDrives.containsKey(action)) 
     156                { 
     157                        effects = new ActionEffectsOnDrives(action); 
     158                        _actionEffectsOnDrives.put(action, effects); 
     159                } 
     160                else 
     161                { 
     162                        effects = _actionEffectsOnDrives.get(action); 
     163                } 
     164                 
     165                effects.AddEffect(new EffectOnDrive(EffectType.ON_PERFORMANCE, driveName, target, value)); 
     166                } 
     167         
     168         
    111169        public void addExpectedGoalEffectOnDrive(String goal, short effectType, String driveName, Symbol target, float value) 
    112170        { 
     
    125183        } 
    126184         
    127         public void addActionEffectsOnDrive(String action, String driveName, Symbol target, float value) 
    128         { 
    129                 ActionEffectsOnDrives effects; 
    130                 if(!_actionEffectsOnDrives.containsKey(action)) 
    131                 { 
    132                         effects = new ActionEffectsOnDrives(action); 
    133                         _actionEffectsOnDrives.put(action, effects); 
    134                 } 
    135                 else 
    136                 { 
    137                         effects = _actionEffectsOnDrives.get(action); 
    138                 } 
    139                  
    140                 effects.AddEffect(new EffectOnDrive(EffectType.ON_PERFORMANCE, driveName, target, value)); 
    141                 } 
    142          
    143         public Motivator[] getMotivators(){ 
    144                 return _motivators; 
    145         } 
    146          
    147185         
    148186        /**  
     
    155193         
    156194         
    157         public Motivator GetMotivator(short motivatorType){ 
    158                 return _motivators[motivatorType]; 
    159         } 
    160          
    161          
    162          
    163         /**  
    164          * Updates the intensity of the motivators based on the event received 
    165          * @throws InvalidMotivatorTypeException  
    166          */ 
    167         public float UpdateMotivators(AgentModel am, Event e) 
    168         { 
    169                 ArrayList<Substitution> substitutions; 
    170                 Symbol target; 
    171                 float deviation = 0; 
    172                 double contributionToNeed =0f; 
    173             float contributionToSelfNeeds = 0f;  //used for events performed by the agent 
    174                  
    175                  
    176                 for(ActionEffectsOnDrives actionEffects : _actionEffectsOnDrives.values()) 
    177                 { 
    178                         Name actionName = actionEffects.getActionName(); 
    179                         substitutions = Unifier.Unify(e.toStepName(),actionName); 
    180                         if(substitutions != null) 
    181                         { 
    182                                 substitutions.add(new Substitution(new Symbol("[AGENT]"),new Symbol(e.GetSubject()))); 
    183                                 for(EffectOnDrive eff : actionEffects.getEffects()) 
    184                                 { 
    185                                         target = (Symbol) eff.getTarget().clone(); 
    186                                         target.MakeGround(substitutions); 
    187                                         if(target.toString().equals(Constants.SELF)) 
    188                                         { 
    189                                                 AgentLogger.GetInstance().log("Updating motivator " + eff.getDriveName()); 
    190                                                 try { 
    191                                                         short driveType = MotivatorType.ParseType(eff.getDriveName()); 
    192                                                         float oldLevel = _motivators[driveType].GetIntensity(); 
    193                                                         deviation = _motivators[driveType].UpdateIntensity(eff.getValue()); 
    194                                                         contributionToNeed = determineQuadraticNeedVariation(oldLevel, deviation)*0.1f; 
    195                                                         contributionToSelfNeeds += contributionToNeed; 
    196                                                 } catch (InvalidMotivatorTypeException e1) { 
    197                                                         e1.printStackTrace(); 
    198                                                 } 
    199                                                  
    200                                         } 
    201                                 } 
    202                                  
    203                                 return contributionToSelfNeeds; //finishes after finding the action that unifies with the event  
    204                         } 
    205                 } 
    206              
    207                 return 0; //no action was found that unified with the event 
     195         
     196        @Override 
     197        public void appraisal(AgentModel am, Event e, AppraisalFrame as) { 
     198                Float desirability = _appraisals.get(e.toString()); 
     199                if(desirability != null) 
     200                { 
     201                        as.SetAppraisalVariable(NAME, (short) 8, OCCAppraisalVariables.DESIRABILITY.name(), desirability.floatValue()); 
     202                } 
     203                _appraisals.remove(e.toString()); 
     204        } 
     205         
     206        @Override 
     207        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     208                return new NeedsPanel(this); 
     209        } 
     210         
     211        @Override 
     212        public IComponent createModelOfOther() { 
     213                MotivationalComponent ms = new MotivationalComponent(new ArrayList<String>()); 
     214                Motivator m2; 
     215                 
     216                for(Motivator m : _motivators) 
     217                { 
     218                        m2 = new Motivator(m); 
     219                        m2.SetIntensity(5); 
     220                        ms.AddMotivator(m2); 
     221                } 
     222                 
     223                ms._actionEffectsOnDrives =  (HashMap<String,ActionEffectsOnDrives>)_actionEffectsOnDrives.clone(); 
     224                ms._goalEffectsOnDrives =  (HashMap<String,ExpectedGoalEffectsOnDrives>)_goalEffectsOnDrives.clone(); 
     225                 
     226                return ms; 
     227        } 
     228         
     229        public float getCompetence(AgentModel am, ActivePursuitGoal g){ 
     230                float generalCompetence = GetIntensity(MotivatorType.COMPETENCE)/10; 
     231                Float probability = g.GetProbability(am); 
     232                 
     233                if(probability != null){ 
     234                        return (generalCompetence + probability.floatValue())/2; 
     235                }else{ 
     236                        //if there is no knowledge about the goal probability, the goal was never executed before 
     237                        //however, the agent assumes that he will be successful in achieving it  
     238                        return (generalCompetence + 1)/2; 
     239                } 
     240        } 
     241         
     242        @Override 
     243        public String[] getComponentDependencies() { 
     244                String[] dependencies = {DeliberativeComponent.NAME}; 
     245                return dependencies; 
    208246        } 
    209247         
     
    298336        } 
    299337         
    300         public float getUtility(AgentModel am, ActivePursuitGoal g) 
    301         { 
    302                 return getContributionToNeeds(am,g) * UTILITY_WEIGHT; 
    303         } 
    304          
    305         public float getProbability(AgentModel am, ActivePursuitGoal g) 
    306         { 
    307                 return getCompetence(am,g); 
    308         } 
    309          
    310         public float getProbability(AgentModel am, Intention i) 
    311         { 
    312                 return i.GetProbability(am); 
    313         } 
    314          
    315         public float getCompetence(AgentModel am, ActivePursuitGoal g){ 
    316                 float generalCompetence = GetIntensity(MotivatorType.COMPETENCE)/10; 
    317                 Float probability = g.GetProbability(am); 
    318                  
    319                 if(probability != null){ 
    320                         return (generalCompetence + probability.floatValue())/2; 
    321                 }else{ 
    322                         //if there is no knowledge about the goal probability, the goal was never executed before 
    323                         //however, the agent assumes that he will be successful in achieving it  
    324                         return (generalCompetence + 1)/2; 
    325                 } 
    326         } 
    327          
    328338 
    329339         
     
    337347        } 
    338348         
     349         
     350         
     351        public Motivator GetMotivator(short motivatorType){ 
     352                return _motivators[motivatorType]; 
     353        } 
     354         
     355         
     356        public Motivator[] getMotivators(){ 
     357                return _motivators; 
     358        } 
    339359         
    340360         
     
    350370        } 
    351371         
    352          
     372        public float getProbability(AgentModel am, ActivePursuitGoal g) 
     373        { 
     374                return getCompetence(am,g); 
     375        } 
     376         
     377        public float getProbability(AgentModel am, Intention i) 
     378        { 
     379                return i.GetProbability(am); 
     380        } 
     381         
     382        public float getUtility(AgentModel am, ActivePursuitGoal g) 
     383        { 
     384                return getContributionToNeeds(am,g) * UTILITY_WEIGHT; 
     385        } 
     386         
     387 
    353388        /** 
    354389         * Gets the received motivator's weight, i.e. how important is the motivator to the agent 
     
    358393        {        
    359394                return _motivators[type].GetWeight(); 
    360         } 
    361          
    362          
    363         /**  
    364          * Calculates the agent's competence about a goal 
    365          * @param succeed - whether a goal has succeeded, true is success, and false is failure 
    366          */ 
    367         public void UpdateCompetence(boolean succeed) 
    368         { 
    369                 Motivator competenceM = _motivators[MotivatorType.COMPETENCE]; 
    370                 //System.out.println("Competence before update" + competenceM.GetIntensity()); 
    371                  
    372                 competenceM.SetIntensity(newCompetence(succeed)); 
    373                 //System.out.println("Competence after update" + competenceM.GetIntensity()); 
    374         } 
    375          
    376         private float newCompetence(boolean succeed) 
    377         { 
    378                 float alpha = 0.25f; 
    379                 int value = 0; 
    380                 float newCompetence; 
    381                 if(succeed) 
    382                 { 
    383                         value = 10; 
    384                 } 
    385                  
    386                 Motivator competenceM = _motivators[MotivatorType.COMPETENCE]; 
    387                  
    388                 newCompetence = alpha * value + (1 - alpha) * competenceM.GetIntensity(); 
    389                  
    390                 if(newCompetence < 1) 
    391                 { 
    392                         newCompetence = 1; 
    393                 } 
    394                  
    395                 return newCompetence; 
    396         } 
    397          
    398         public float PredictCompetenceChange(boolean succeed) 
    399         { 
    400                 Motivator competenceM = _motivators[MotivatorType.COMPETENCE]; 
    401                 return newCompetence(succeed) - competenceM.GetIntensity(); 
    402         } 
    403          
    404         /** 
    405          * Update the agent's certainty value 
    406          * @param expectation - ranges from -1 to 1, -1 means complete violation of expectation while 
    407          *                                              1 means complete fulfillment of expectation 
    408          * Changed the factor from 10 to 3 (Meiyii) 
    409          */ 
    410         public void UpdateCertainty(float expectation) 
    411         { 
    412                 //System.out.println("Certainty before update" + _selfMotivators[MotivatorType.CERTAINTY].GetIntensity()); 
    413                 _motivators[MotivatorType.CERTAINTY].UpdateIntensity(expectation*3); 
    414                 //System.out.println("Certainty after update" + _selfMotivators[MotivatorType.CERTAINTY].GetIntensity()); 
    415         } 
    416          
    417  
    418         /** 
    419          * Converts the motivational state to XML 
    420          * @return a XML String that contains all information in the motivational state 
    421          */ 
    422         public String toXml() { 
    423                 String result; 
    424  
    425                 result = "<MotivationalState>"; 
    426                 for(int i = 0; i < _motivators.length; i++){ 
    427                         result = result + _motivators[i].toXml(); 
    428                 } 
    429                  
    430                 result = result + "</MotivationalState>"; 
    431                 return result; 
    432         } 
    433  
    434  
    435         @Override 
    436         public String name() { 
    437                 return MotivationalComponent.NAME; 
    438         } 
    439  
    440  
    441         @Override 
    442         public void reset() { 
    443                 // TODO Auto-generated method stub 
    444         } 
    445          
    446         @Override 
    447         public void update(AgentModel am, Event e) 
    448         { 
    449                 float result =  UpdateMotivators(am, e); 
    450                 _appraisals.put(e.toString(), new Float(result * EFFECT_ON_DRIVES_WEIGHT)); 
    451         } 
    452  
    453         @Override 
    454         public void appraisal(AgentModel am, Event e, AppraisalFrame as) { 
    455                 Float desirability = _appraisals.get(e.toString()); 
    456                 if(desirability != null) 
    457                 { 
    458                         as.SetAppraisalVariable(NAME, (short) 8, OCCAppraisalVariables.DESIRABILITY.name(), desirability.floatValue()); 
    459                 } 
    460                 _appraisals.remove(e.toString()); 
    461395        } 
    462396 
     
    474408                LoadNeeds(am); 
    475409        } 
    476          
    477         private void LoadNeeds(AgentModel am) 
    478         { 
    479                 AgentLogger.GetInstance().log("LOADING Needs: "); 
    480                 NeedsLoaderHandler needsLoader = new NeedsLoaderHandler(am,this); 
    481                  
    482                 try{ 
    483                         SAXParserFactory factory = SAXParserFactory.newInstance(); 
    484                         SAXParser parser = factory.newSAXParser(); 
    485                          
    486                         for(String file : _parsingFiles) 
    487                         { 
    488                                 parser.parse(new File(file), needsLoader); 
    489                         }        
    490  
    491                 }catch(Exception e){ 
    492                         throw new RuntimeException("Error on Loading Needs from XML Files:" + e); 
    493                 } 
    494         } 
    495  
    496  
    497         @Override 
    498         public void update(AgentModel am, long time) { 
    499                 _appraisals.clear(); 
    500                 if (time >= _lastTime + 1000) { 
    501                         _lastTime = time; 
    502                          
    503                         //decay self motivators 
    504                         for(int i = 0; i < _motivators.length; i++){ 
    505                                 _motivators[i].DecayMotivator(); 
    506                         } 
    507                          
    508                 } 
    509         } 
    510  
    511  
    512         @Override 
    513         public IComponent createModelOfOther() { 
    514                 MotivationalComponent ms = new MotivationalComponent(new ArrayList<String>()); 
    515                 Motivator m2; 
    516                  
    517                 for(Motivator m : _motivators) 
    518                 { 
    519                         m2 = new Motivator(m); 
    520                         m2.SetIntensity(5); 
    521                         ms.AddMotivator(m2); 
    522                 } 
    523                  
    524                 ms._actionEffectsOnDrives =  (HashMap<String,ActionEffectsOnDrives>)_actionEffectsOnDrives.clone(); 
    525                 ms._goalEffectsOnDrives =  (HashMap<String,ExpectedGoalEffectsOnDrives>)_goalEffectsOnDrives.clone(); 
    526                  
    527                 return ms; 
    528         } 
    529  
    530  
    531         @Override 
    532         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    533                 return new NeedsPanel(this); 
    534         } 
    535  
    536  
     410 
     411 
     412        @Override 
     413        public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
     414                //TODO 
     415        } 
     416         
     417        @Override 
     418        public String name() { 
     419                return MotivationalComponent.NAME; 
     420        } 
     421 
     422        @Override 
     423        public void perceiveActionFailure(AgentModel am, Step a) { 
     424                //System.out.println("Calling UpdateCertainty (other's action: step completed)"); 
     425                UpdateCertainty(-a.getProbability(am)); 
     426        } 
     427 
     428 
     429        @Override 
     430        public void perceiveGoalFailure(AgentModel am, ActivePursuitGoal g) { 
     431                //_numberOfGoalsTried++; 
     432                UpdateCompetence(false); 
     433                 
     434            //observed error = |estimation of success - realsuccess| 
     435            //given that the goal failed, the real success is none and the formula resumes to 
     436            //observed error = estimation of success - 0 (=) estimation of success 
     437            float observedError = g.getProbability(am); 
     438            float previousExpectedError = g.getUncertainty(am); 
     439             
     440            float newExpectedError = ActivePursuitGoal.alfa * observedError + (1 - ActivePursuitGoal.alfa) * previousExpectedError; 
     441            float deltaError = newExpectedError - previousExpectedError; 
     442            UpdateCertainty(-deltaError); 
     443            g.setUncertainty(am, newExpectedError); 
     444        } 
     445         
    537446        @Override 
    538447        public void perceiveGoalSuccess(AgentModel am, ActivePursuitGoal g) { 
     
    553462 
    554463 
    555         @Override 
    556         public void perceiveGoalFailure(AgentModel am, ActivePursuitGoal g) { 
    557                 //_numberOfGoalsTried++; 
    558                 UpdateCompetence(false); 
    559                  
    560             //observed error = |estimation of success - realsuccess| 
    561             //given that the goal failed, the real success is none and the formula resumes to 
    562             //observed error = estimation of success - 0 (=) estimation of success 
    563             float observedError = g.getProbability(am); 
    564             float previousExpectedError = g.getUncertainty(am); 
    565              
    566             float newExpectedError = ActivePursuitGoal.alfa * observedError + (1 - ActivePursuitGoal.alfa) * previousExpectedError; 
    567             float deltaError = newExpectedError - previousExpectedError; 
    568             UpdateCertainty(-deltaError); 
    569             g.setUncertainty(am, newExpectedError); 
    570         } 
    571  
    572  
    573         @Override 
    574         public void perceiveActionFailure(AgentModel am, Step a) { 
    575                 //System.out.println("Calling UpdateCertainty (other's action: step completed)"); 
    576                 UpdateCertainty(-a.getProbability(am)); 
     464        public float PredictCompetenceChange(boolean succeed) 
     465        { 
     466                Motivator competenceM = _motivators[MotivatorType.COMPETENCE]; 
     467                return newCompetence(succeed) - competenceM.GetIntensity(); 
    577468        } 
    578469 
     
    585476 
    586477        @Override 
    587         public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
    588                 //TODO 
     478        public void reset() { 
     479                // TODO Auto-generated method stub 
     480        } 
     481 
     482 
     483        /** 
     484         * Converts the motivational state to XML 
     485         * @return a XML String that contains all information in the motivational state 
     486         */ 
     487        public String toXml() { 
     488                String result; 
     489 
     490                result = "<MotivationalState>"; 
     491                for(int i = 0; i < _motivators.length; i++){ 
     492                        result = result + _motivators[i].toXml(); 
     493                } 
     494                 
     495                result = result + "</MotivationalState>"; 
     496                return result; 
     497        } 
     498 
     499 
     500        @Override 
     501        public void update(AgentModel am, Event e) 
     502        { 
     503                float result =  UpdateMotivators(am, e); 
     504                _appraisals.put(e.toString(), new Float(result * EFFECT_ON_DRIVES_WEIGHT)); 
     505        } 
     506 
     507 
     508        @Override 
     509        public void update(AgentModel am, long time) { 
     510                _appraisals.clear(); 
     511                if (time >= _lastTime + 1000) { 
     512                        _lastTime = time; 
     513                         
     514                        //decay self motivators 
     515                        for(int i = 0; i < _motivators.length; i++){ 
     516                                _motivators[i].DecayMotivator(); 
     517                        } 
     518                         
     519                } 
     520        } 
     521 
     522 
     523        /** 
     524         * Update the agent's certainty value 
     525         * @param expectation - ranges from -1 to 1, -1 means complete violation of expectation while 
     526         *                                              1 means complete fulfillment of expectation 
     527         * Changed the factor from 10 to 3 (Meiyii) 
     528         */ 
     529        public void UpdateCertainty(float expectation) 
     530        { 
     531                //System.out.println("Certainty before update" + _selfMotivators[MotivatorType.CERTAINTY].GetIntensity()); 
     532                _motivators[MotivatorType.CERTAINTY].UpdateIntensity(expectation*3); 
     533                //System.out.println("Certainty after update" + _selfMotivators[MotivatorType.CERTAINTY].GetIntensity()); 
     534        } 
     535 
     536 
     537        /**  
     538         * Calculates the agent's competence about a goal 
     539         * @param succeed - whether a goal has succeeded, true is success, and false is failure 
     540         */ 
     541        public void UpdateCompetence(boolean succeed) 
     542        { 
     543                Motivator competenceM = _motivators[MotivatorType.COMPETENCE]; 
     544                //System.out.println("Competence before update" + competenceM.GetIntensity()); 
     545                 
     546                competenceM.SetIntensity(newCompetence(succeed)); 
     547                //System.out.println("Competence after update" + competenceM.GetIntensity()); 
     548        } 
     549         
     550        /**  
     551         * Updates the intensity of the motivators based on the event received 
     552         * @throws InvalidMotivatorTypeException  
     553         */ 
     554        public float UpdateMotivators(AgentModel am, Event e) 
     555        { 
     556                ArrayList<Substitution> substitutions; 
     557                Symbol target; 
     558                float deviation = 0; 
     559                double contributionToNeed =0f; 
     560            float contributionToSelfNeeds = 0f;  //used for events performed by the agent 
     561                 
     562                 
     563                for(ActionEffectsOnDrives actionEffects : _actionEffectsOnDrives.values()) 
     564                { 
     565                        Name actionName = actionEffects.getActionName(); 
     566                        substitutions = Unifier.Unify(e.toStepName(),actionName); 
     567                        if(substitutions != null) 
     568                        { 
     569                                substitutions.add(new Substitution(new Symbol("[AGENT]"),new Symbol(e.GetSubject()))); 
     570                                for(EffectOnDrive eff : actionEffects.getEffects()) 
     571                                { 
     572                                        target = (Symbol) eff.getTarget().clone(); 
     573                                        target.MakeGround(substitutions); 
     574                                        if(target.toString().equals(Constants.SELF)) 
     575                                        { 
     576                                                AgentLogger.GetInstance().log("Updating motivator " + eff.getDriveName()); 
     577                                                try { 
     578                                                        short driveType = MotivatorType.ParseType(eff.getDriveName()); 
     579                                                        float oldLevel = _motivators[driveType].GetIntensity(); 
     580                                                        deviation = _motivators[driveType].UpdateIntensity(eff.getValue()); 
     581                                                        contributionToNeed = determineQuadraticNeedVariation(oldLevel, deviation)*0.1f; 
     582                                                        contributionToSelfNeeds += contributionToNeed; 
     583                                                } catch (InvalidMotivatorTypeException e1) { 
     584                                                        e1.printStackTrace(); 
     585                                                } 
     586                                                 
     587                                        } 
     588                                } 
     589                                 
     590                                return contributionToSelfNeeds; //finishes after finding the action that unifies with the event  
     591                        } 
     592                } 
     593             
     594                return 0; //no action was found that unified with the event 
    589595        } 
    590596} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.OCCAffectDerivation/src/FAtiMA/OCCAffectDerivation/OCCAffectDerivationComponent.java

    r971 r972  
    2525        public static final int GOALDISCONFIRMED = 2; 
    2626         
     27        private static OCCBaseEmotion AppraiseGoalEnd(OCCEmotionType hopefullOutcome, OCCEmotionType fearfullOutcome,  
     28                        ActiveEmotion hopeEmotion, ActiveEmotion fearEmotion, float goalConduciveness, Event e) { 
     29         
     30                OCCEmotionType finalEmotion; 
     31                float potential = 0; 
     32                 
     33                if(hopeEmotion != null) { 
     34                        if(fearEmotion != null && fearEmotion.GetIntensity() > hopeEmotion.GetIntensity()) { 
     35                                potential = fearEmotion.GetPotential(); 
     36                                finalEmotion = fearfullOutcome; 
     37                        } 
     38                        else { 
     39                                potential = hopeEmotion.GetPotential(); 
     40                                finalEmotion = hopefullOutcome; 
     41                        } 
     42                } 
     43                else if(fearEmotion != null) { 
     44                        potential = fearEmotion.GetPotential(); 
     45                        finalEmotion = fearfullOutcome; 
     46                } 
     47                else return null; 
     48                 
     49                //Change, the goal importance now affects 66% of the final potential value for the emotion 
     50                potential = (potential +  2* goalConduciveness) / 3; 
     51                 
     52                return new OCCBaseEmotion(finalEmotion, potential, e); 
     53        } 
     54 
     55        private static OCCBaseEmotion OCCAppraiseAttribution(Event event, float like) 
     56        { 
     57                OCCBaseEmotion em; 
     58                 
     59                if(like >= 0) { 
     60                        em = new OCCBaseEmotion(OCCEmotionType.LOVE, like*0.7f, event, Name.ParseName(event.GetTarget())); 
     61                } 
     62                else { 
     63                        em = new OCCBaseEmotion(OCCEmotionType.HATE, -like*0.7f, event, Name.ParseName(event.GetTarget())); 
     64                } 
     65                 
     66                return em; 
     67        } 
     68 
     69        private static OCCBaseEmotion OCCAppraiseFortuneOfOthers(Event event, float desirability, float desirabilityForOther, String target) { 
     70                OCCBaseEmotion em; 
     71                float potential; 
     72                 
     73                potential = (Math.abs(desirabilityForOther) + Math.abs(desirability)) / 2.0f; 
     74                 
     75                if(desirability >= 0) { 
     76                        if(desirabilityForOther >= 0) { 
     77                                em = new OCCBaseEmotion(OCCEmotionType.HAPPY_FOR, potential, event, Name.ParseName(target));     
     78                        } 
     79                        else { 
     80                                em = new OCCBaseEmotion(OCCEmotionType.GLOATING,potential, event, Name.ParseName(target)); 
     81                        } 
     82                } 
     83                else { 
     84                        if(desirabilityForOther >= 0) { 
     85                                em = new OCCBaseEmotion(OCCEmotionType.RESENTMENT, potential, event, Name.ParseName(target)); 
     86                        } 
     87                        else { 
     88                                em = new OCCBaseEmotion(OCCEmotionType.PITTY, potential, event, Name.ParseName(target)); 
     89                        } 
     90                } 
     91                 
     92                return em; 
     93        } 
     94 
     95        private static OCCBaseEmotion OCCAppraisePraiseworthiness(String appraisingAgent, Event event, float praiseworthiness) { 
     96                OCCBaseEmotion em; 
     97                 
     98                if(praiseworthiness >= 0) { 
     99                        if(event.GetSubject().equals(appraisingAgent)) { 
     100                                em = new OCCBaseEmotion(OCCEmotionType.PRIDE, praiseworthiness, event, Name.ParseName("SELF")); 
     101                        } 
     102                        else { 
     103                                em = new OCCBaseEmotion(OCCEmotionType.ADMIRATION, praiseworthiness, event, Name.ParseName(event.GetSubject())); 
     104                        } 
     105                } 
     106                else { 
     107                        if(event.GetSubject().equals(appraisingAgent)) { 
     108                                em = new OCCBaseEmotion(OCCEmotionType.SHAME, -praiseworthiness, event, Name.ParseName("SELF")); 
     109                        } 
     110                        else { 
     111                                em = new OCCBaseEmotion(OCCEmotionType.REPROACH, -praiseworthiness, event, Name.ParseName(event.GetSubject())); 
     112                        } 
     113                } 
     114                 
     115                return em; 
     116        } 
     117 
     118        private static OCCBaseEmotion OCCAppraiseWellBeing(Event event, float desirability) { 
     119                OCCBaseEmotion em; 
     120                 
     121                if(desirability >= 0) { 
     122                        em = new OCCBaseEmotion(OCCEmotionType.JOY, desirability, event); 
     123                } 
     124                else { 
     125                        em = new OCCBaseEmotion(OCCEmotionType.DISTRESS, -desirability, event); 
     126                } 
     127                return em; 
     128        } 
     129         
     130        /** 
     131         * Appraises a Goal's Failure according to the emotions that the agent is experiencing 
     132         * @param hopeEmotion - the emotion of Hope for achieving the goal that the character feels 
     133         * @param fearEmotion - the emotion of Fear for not achieving the goal that the character feels 
     134         * @param g - the Goal that failed 
     135         */ 
     136        public static OCCBaseEmotion AppraiseGoalFailure(AgentModel am, ActiveEmotion hopeEmotion, ActiveEmotion fearEmotion, float conduciveness, Event e) { 
     137                return AppraiseGoalEnd(OCCEmotionType.DISAPPOINTMENT,OCCEmotionType.FEARS_CONFIRMED,hopeEmotion,fearEmotion,conduciveness,e); 
     138        } 
     139 
     140        /** 
     141         * Appraises a Goal's likelihood of failure 
     142         * @param g - the goal 
     143         * @param probability - the probability of the goal to fail 
     144         * @return - the emotion created 
     145         */ 
     146        public static OCCBaseEmotion AppraiseGoalFailureProbability(AgentModel am , Event e, float goalConduciveness, float prob) 
     147        { 
     148                float potential; 
     149                potential = prob * goalConduciveness; 
     150                 
     151                OCCBaseEmotion em = new  OCCBaseEmotion(OCCEmotionType.FEAR, potential, e); 
     152                 
     153                return em; 
     154        } 
     155         
     156        /** 
     157         * Appraises a Goal's success according to the emotions that the agent is experiencing 
     158         * @param hopeEmotion - the emotion of Hope for achieving the goal that the character feels 
     159         * @param fearEmotion - the emotion of Fear for not achieving the goal that the character feels 
     160         * @param g - the Goal that succeeded 
     161         * @return - the emotion created 
     162         */ 
     163        public static OCCBaseEmotion AppraiseGoalSuccess(AgentModel am, ActiveEmotion hopeEmotion, ActiveEmotion fearEmotion, float conduciveness, Event e) { 
     164                return AppraiseGoalEnd(OCCEmotionType.SATISFACTION,OCCEmotionType.RELIEF,hopeEmotion,fearEmotion,conduciveness,e); 
     165        } 
     166         
     167        /** 
     168         * Appraises a Goal's likelihood of succeeding 
     169         * @param g - the goal 
     170         * @param probability - the probability of the goal to succeed 
     171         * @return - the BaseEmotion created 
     172         */ 
     173        public static OCCBaseEmotion AppraiseGoalSuccessProbability(AgentModel am, Event e, float goalConduciveness, float prob) { 
     174         
     175                float potential; 
     176                potential = prob * goalConduciveness; 
     177         
     178                OCCBaseEmotion em = new  OCCBaseEmotion(OCCEmotionType.HOPE, potential, e); 
     179         
     180                return em; 
     181        } 
     182         
    27183        public OCCAffectDerivationComponent() 
    28184        { 
    29         } 
    30  
    31         @Override 
    32         public String name() { 
    33                 return NAME; 
    34         } 
    35  
    36         @Override 
    37         public void initialize(AgentModel am) { 
    38         } 
    39  
    40         @Override 
    41         public void reset() { 
    42         } 
    43  
    44         @Override 
    45         public void update(AgentModel am, long time) { 
    46         } 
    47          
    48         @Override 
    49         public void update(AgentModel am, Event e) 
    50         { 
    51         } 
    52  
    53         @Override 
    54         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    55                 return null; 
    56185        } 
    57186         
     
    151280         
    152281        @Override 
     282        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     283                return null; 
     284        } 
     285 
     286         
     287        @Override 
     288        public IComponent createModelOfOther() { 
     289                return new OCCAffectDerivationComponent(); 
     290        } 
     291         
     292        @Override 
     293        public String[] getComponentDependencies() { 
     294                String[] dependencies = {}; 
     295                return dependencies; 
     296        } 
     297         
     298        @Override 
     299        public void initialize(AgentModel am) { 
     300        } 
     301         
     302         
     303 
     304        @Override 
    153305        public void inverseAffectDerivation(AgentModel am, BaseEmotion em, AppraisalFrame af) 
    154306        { 
     
    194346                } 
    195347        } 
    196          
    197         private static OCCBaseEmotion OCCAppraiseAttribution(Event event, float like) 
    198         { 
    199                 OCCBaseEmotion em; 
    200                  
    201                 if(like >= 0) { 
    202                         em = new OCCBaseEmotion(OCCEmotionType.LOVE, like*0.7f, event, Name.ParseName(event.GetTarget())); 
    203                 } 
    204                 else { 
    205                         em = new OCCBaseEmotion(OCCEmotionType.HATE, -like*0.7f, event, Name.ParseName(event.GetTarget())); 
    206                 } 
    207                  
    208                 return em; 
    209         } 
    210          
    211         private static OCCBaseEmotion OCCAppraiseWellBeing(Event event, float desirability) { 
    212                 OCCBaseEmotion em; 
    213                  
    214                 if(desirability >= 0) { 
    215                         em = new OCCBaseEmotion(OCCEmotionType.JOY, desirability, event); 
    216                 } 
    217                 else { 
    218                         em = new OCCBaseEmotion(OCCEmotionType.DISTRESS, -desirability, event); 
    219                 } 
    220                 return em; 
    221         } 
    222          
    223         private static OCCBaseEmotion OCCAppraisePraiseworthiness(String appraisingAgent, Event event, float praiseworthiness) { 
    224                 OCCBaseEmotion em; 
    225                  
    226                 if(praiseworthiness >= 0) { 
    227                         if(event.GetSubject().equals(appraisingAgent)) { 
    228                                 em = new OCCBaseEmotion(OCCEmotionType.PRIDE, praiseworthiness, event, Name.ParseName("SELF")); 
    229                         } 
    230                         else { 
    231                                 em = new OCCBaseEmotion(OCCEmotionType.ADMIRATION, praiseworthiness, event, Name.ParseName(event.GetSubject())); 
    232                         } 
    233                 } 
    234                 else { 
    235                         if(event.GetSubject().equals(appraisingAgent)) { 
    236                                 em = new OCCBaseEmotion(OCCEmotionType.SHAME, -praiseworthiness, event, Name.ParseName("SELF")); 
    237                         } 
    238                         else { 
    239                                 em = new OCCBaseEmotion(OCCEmotionType.REPROACH, -praiseworthiness, event, Name.ParseName(event.GetSubject())); 
    240                         } 
    241                 } 
    242                  
    243                 return em; 
    244         } 
    245  
    246          
    247         /** 
    248          * Appraises a Goal's likelihood of failure 
    249          * @param g - the goal 
    250          * @param probability - the probability of the goal to fail 
    251          * @return - the emotion created 
    252          */ 
    253         public static OCCBaseEmotion AppraiseGoalFailureProbability(AgentModel am , Event e, float goalConduciveness, float prob) 
    254         { 
    255                 float potential; 
    256                 potential = prob * goalConduciveness; 
    257                  
    258                 OCCBaseEmotion em = new  OCCBaseEmotion(OCCEmotionType.FEAR, potential, e); 
    259                  
    260                 return em; 
    261         } 
    262          
    263         /** 
    264          * Appraises a Goal's likelihood of succeeding 
    265          * @param g - the goal 
    266          * @param probability - the probability of the goal to succeed 
    267          * @return - the BaseEmotion created 
    268          */ 
    269         public static OCCBaseEmotion AppraiseGoalSuccessProbability(AgentModel am, Event e, float goalConduciveness, float prob) { 
    270          
    271                 float potential; 
    272                 potential = prob * goalConduciveness; 
    273          
    274                 OCCBaseEmotion em = new  OCCBaseEmotion(OCCEmotionType.HOPE, potential, e); 
    275          
    276                 return em; 
    277         } 
    278          
    279         /** 
    280          * Appraises a Goal's Failure according to the emotions that the agent is experiencing 
    281          * @param hopeEmotion - the emotion of Hope for achieving the goal that the character feels 
    282          * @param fearEmotion - the emotion of Fear for not achieving the goal that the character feels 
    283          * @param g - the Goal that failed 
    284          */ 
    285         public static OCCBaseEmotion AppraiseGoalFailure(AgentModel am, ActiveEmotion hopeEmotion, ActiveEmotion fearEmotion, float conduciveness, Event e) { 
    286                 return AppraiseGoalEnd(OCCEmotionType.DISAPPOINTMENT,OCCEmotionType.FEARS_CONFIRMED,hopeEmotion,fearEmotion,conduciveness,e); 
    287         } 
    288          
    289          
    290  
    291         /** 
    292          * Appraises a Goal's success according to the emotions that the agent is experiencing 
    293          * @param hopeEmotion - the emotion of Hope for achieving the goal that the character feels 
    294          * @param fearEmotion - the emotion of Fear for not achieving the goal that the character feels 
    295          * @param g - the Goal that succeeded 
    296          * @return - the emotion created 
    297          */ 
    298         public static OCCBaseEmotion AppraiseGoalSuccess(AgentModel am, ActiveEmotion hopeEmotion, ActiveEmotion fearEmotion, float conduciveness, Event e) { 
    299                 return AppraiseGoalEnd(OCCEmotionType.SATISFACTION,OCCEmotionType.RELIEF,hopeEmotion,fearEmotion,conduciveness,e); 
    300         } 
    301  
    302          
    303          
    304         private static OCCBaseEmotion OCCAppraiseFortuneOfOthers(Event event, float desirability, float desirabilityForOther, String target) { 
    305                 OCCBaseEmotion em; 
    306                 float potential; 
    307                  
    308                 potential = (Math.abs(desirabilityForOther) + Math.abs(desirability)) / 2.0f; 
    309                  
    310                 if(desirability >= 0) { 
    311                         if(desirabilityForOther >= 0) { 
    312                                 em = new OCCBaseEmotion(OCCEmotionType.HAPPY_FOR, potential, event, Name.ParseName(target));     
    313                         } 
    314                         else { 
    315                                 em = new OCCBaseEmotion(OCCEmotionType.GLOATING,potential, event, Name.ParseName(target)); 
    316                         } 
    317                 } 
    318                 else { 
    319                         if(desirabilityForOther >= 0) { 
    320                                 em = new OCCBaseEmotion(OCCEmotionType.RESENTMENT, potential, event, Name.ParseName(target)); 
    321                         } 
    322                         else { 
    323                                 em = new OCCBaseEmotion(OCCEmotionType.PITTY, potential, event, Name.ParseName(target)); 
    324                         } 
    325                 } 
    326                  
    327                 return em; 
    328         } 
    329          
    330         private static OCCBaseEmotion AppraiseGoalEnd(OCCEmotionType hopefullOutcome, OCCEmotionType fearfullOutcome,  
    331                         ActiveEmotion hopeEmotion, ActiveEmotion fearEmotion, float goalConduciveness, Event e) { 
    332          
    333                 OCCEmotionType finalEmotion; 
    334                 float potential = 0; 
    335                  
    336                 if(hopeEmotion != null) { 
    337                         if(fearEmotion != null && fearEmotion.GetIntensity() > hopeEmotion.GetIntensity()) { 
    338                                 potential = fearEmotion.GetPotential(); 
    339                                 finalEmotion = fearfullOutcome; 
    340                         } 
    341                         else { 
    342                                 potential = hopeEmotion.GetPotential(); 
    343                                 finalEmotion = hopefullOutcome; 
    344                         } 
    345                 } 
    346                 else if(fearEmotion != null) { 
    347                         potential = fearEmotion.GetPotential(); 
    348                         finalEmotion = fearfullOutcome; 
    349                 } 
    350                 else return null; 
    351                  
    352                 //Change, the goal importance now affects 66% of the final potential value for the emotion 
    353                 potential = (potential +  2* goalConduciveness) / 3; 
    354                  
    355                 return new OCCBaseEmotion(finalEmotion, potential, e); 
    356         } 
    357  
    358         @Override 
    359         public IComponent createModelOfOther() { 
    360                 return new OCCAffectDerivationComponent(); 
     348 
     349         
     350         
     351        @Override 
     352        public String name() { 
     353                return NAME; 
     354        } 
     355         
     356        @Override 
     357        public void reset() { 
     358        } 
     359 
     360        @Override 
     361        public void update(AgentModel am, Event e) 
     362        { 
     363        } 
     364         
     365        @Override 
     366        public void update(AgentModel am, long time) { 
    361367        } 
    362368} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.ReactiveComponent/src/FAtiMA/ReactiveComponent/ReactiveComponent.java

    r970 r972  
    236236        } 
    237237         
     238        @Override 
     239        public String[] getComponentDependencies() { 
     240                String[] dependencies = {}; 
     241                return dependencies; 
     242        } 
     243 
    238244        /** 
    239245         * Gets the agent's emotional reactions 
     
    279285                } 
    280286        } 
    281  
     287         
    282288        @Override 
    283289        public String name() { 
    284290                return ReactiveComponent.NAME; 
    285291        } 
     292 
    286293         
    287294        @Override 
     
    290297        } 
    291298 
    292          
    293299        /** 
    294300         * Resets the reactive layer, clearing all received events that 
     
    308314        { 
    309315        } 
    310  
     316         
    311317        @Override 
    312318        public void update(AgentModel am,long time) { 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.SocialRelations/src/FAtiMA/socialRelations/SocialRelationsComponent.java

    r970 r972  
    6868 
    6969        @Override 
    70         public String name() { 
    71                 return SocialRelationsComponent.NAME; 
    72         } 
    73  
    74         @Override 
    75         public void initialize(AgentModel am) { 
    76                 this.loadRelations(am); 
    77         } 
    78  
    79         @Override 
    80         public void reset() { 
    81         } 
    82  
    83         @Override 
    84         public void update(AgentModel am, long time) { 
    85         } 
    86  
    87         @Override 
    88         public void update(AgentModel am, Event e) { 
    89         } 
    90  
    91         @Override 
    9270        public void appraisal(AgentModel am, Event e, AppraisalFrame as) 
    9371        { 
     
    9977                        } 
    10078                } 
     79        } 
     80 
     81        @Override 
     82        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     83                return new SocialRelationsPanel(); 
     84        } 
     85 
     86        @Override 
     87        public IComponent createModelOfOther() { 
     88                return new SocialRelationsComponent(new ArrayList<String>()); 
     89        } 
     90 
     91        @Override 
     92        public void emotionActivation(AgentModel am, ActiveEmotion em) { 
     93                Memory m = am.getMemory(); 
     94                if (em.getType().equalsIgnoreCase(OCCEmotionType.ADMIRATION.name()))  
     95                { 
     96                        if (em.GetDirection() != null)  
     97                        { 
     98                                LikeRelation.getRelation(Constants.SELF, em.GetDirection().toString()).increment(m, em.GetIntensity()); 
     99                                RespectRelation.getRelation(Constants.SELF, em.GetDirection().toString()).increment(m,em.GetIntensity()); 
     100                        } 
     101                } else if (em.getType().equalsIgnoreCase(OCCEmotionType.REPROACH.name()))  
     102                { 
     103                        if (em.GetDirection() != null)  
     104                        { 
     105                                LikeRelation.getRelation(Constants.SELF, em.GetDirection().toString()).decrement(m,em.GetIntensity()); 
     106                                RespectRelation.getRelation(Constants.SELF, em.GetDirection().toString()).decrement(m,em.GetIntensity()); 
     107                        } 
     108                } else if (em.getType().equalsIgnoreCase(OCCEmotionType.HAPPY_FOR.name()))  
     109                { 
     110                        if (em.GetDirection() != null) { 
     111                                LikeRelation.getRelation(Constants.SELF, em.GetDirection().toString()).increment(m, 
     112 
     113                                em.GetIntensity()); 
     114                        } 
     115                } else if (em.getType().equalsIgnoreCase 
     116 
     117                (OCCEmotionType.GLOATING.name())) { 
     118                        if (em.GetDirection() != null) { 
     119                                LikeRelation.getRelation 
     120 
     121                                (Constants.SELF, em.GetDirection().toString()).decrement(m, 
     122 
     123                                em.GetIntensity()); 
     124                        } 
     125                } else if (em.getType().equalsIgnoreCase 
     126 
     127                (OCCEmotionType.PITTY.name())) { 
     128                        if (em.GetDirection() != null) { 
     129                                LikeRelation.getRelation 
     130 
     131                                (Constants.SELF, em.GetDirection().toString()).increment(m, 
     132 
     133                                em.GetIntensity()); 
     134                        } 
     135                } else if (em.getType().equalsIgnoreCase 
     136 
     137                (OCCEmotionType.RESENTMENT.name())) { 
     138                        if (em.GetDirection() != null) { 
     139                                LikeRelation.getRelation 
     140 
     141                                (Constants.SELF, em.GetDirection().toString()).decrement(m, 
     142 
     143                                em.GetIntensity()); 
     144                        } 
     145                } else if (em.getType().equalsIgnoreCase 
     146 
     147                (OCCEmotionType.JOY.name())) { 
     148                        if (em.GetCause().GetTarget() != null && 
     149 
     150                        em.GetCause().GetTarget().equals(Constants.SELF)) { 
     151                                LikeRelation.getRelation 
     152 
     153                                (Constants.SELF, em.GetCause().GetSubject()).increment(m, 
     154 
     155                                em.GetIntensity()); 
     156                        } 
     157                } else if (em.getType().equalsIgnoreCase 
     158 
     159                (OCCEmotionType.DISTRESS.name())) { 
     160                        if (em.GetCause().GetTarget() != null && 
     161 
     162                        em.GetCause().GetTarget().equals(Constants.SELF)) { 
     163                                LikeRelation.getRelation 
     164 
     165                                (Constants.SELF, em.GetCause().GetSubject()).decrement(m, 
     166 
     167                                em.GetIntensity()); 
     168                        } 
     169                } 
     170        } 
     171 
     172        @Override 
     173        public String[] getComponentDependencies() { 
     174                String[] dependencies = {}; 
     175                return dependencies; 
     176        } 
     177 
     178        @Override 
     179        public void initialize(AgentModel am) { 
     180                this.loadRelations(am); 
    101181        } 
    102182 
     
    116196 
    117197        @Override 
    118         public void emotionActivation(AgentModel am, ActiveEmotion em) { 
    119                 Memory m = am.getMemory(); 
    120                 if (em.getType().equalsIgnoreCase(OCCEmotionType.ADMIRATION.name()))  
    121                 { 
    122                         if (em.GetDirection() != null)  
    123                         { 
    124                                 LikeRelation.getRelation(Constants.SELF, em.GetDirection().toString()).increment(m, em.GetIntensity()); 
    125                                 RespectRelation.getRelation(Constants.SELF, em.GetDirection().toString()).increment(m,em.GetIntensity()); 
    126                         } 
    127                 } else if (em.getType().equalsIgnoreCase(OCCEmotionType.REPROACH.name()))  
    128                 { 
    129                         if (em.GetDirection() != null)  
    130                         { 
    131                                 LikeRelation.getRelation(Constants.SELF, em.GetDirection().toString()).decrement(m,em.GetIntensity()); 
    132                                 RespectRelation.getRelation(Constants.SELF, em.GetDirection().toString()).decrement(m,em.GetIntensity()); 
    133                         } 
    134                 } else if (em.getType().equalsIgnoreCase(OCCEmotionType.HAPPY_FOR.name()))  
    135                 { 
    136                         if (em.GetDirection() != null) { 
    137                                 LikeRelation.getRelation(Constants.SELF, em.GetDirection().toString()).increment(m, 
    138  
    139                                 em.GetIntensity()); 
    140                         } 
    141                 } else if (em.getType().equalsIgnoreCase 
    142  
    143                 (OCCEmotionType.GLOATING.name())) { 
    144                         if (em.GetDirection() != null) { 
    145                                 LikeRelation.getRelation 
    146  
    147                                 (Constants.SELF, em.GetDirection().toString()).decrement(m, 
    148  
    149                                 em.GetIntensity()); 
    150                         } 
    151                 } else if (em.getType().equalsIgnoreCase 
    152  
    153                 (OCCEmotionType.PITTY.name())) { 
    154                         if (em.GetDirection() != null) { 
    155                                 LikeRelation.getRelation 
    156  
    157                                 (Constants.SELF, em.GetDirection().toString()).increment(m, 
    158  
    159                                 em.GetIntensity()); 
    160                         } 
    161                 } else if (em.getType().equalsIgnoreCase 
    162  
    163                 (OCCEmotionType.RESENTMENT.name())) { 
    164                         if (em.GetDirection() != null) { 
    165                                 LikeRelation.getRelation 
    166  
    167                                 (Constants.SELF, em.GetDirection().toString()).decrement(m, 
    168  
    169                                 em.GetIntensity()); 
    170                         } 
    171                 } else if (em.getType().equalsIgnoreCase 
    172  
    173                 (OCCEmotionType.JOY.name())) { 
    174                         if (em.GetCause().GetTarget() != null && 
    175  
    176                         em.GetCause().GetTarget().equals(Constants.SELF)) { 
    177                                 LikeRelation.getRelation 
    178  
    179                                 (Constants.SELF, em.GetCause().GetSubject()).increment(m, 
    180  
    181                                 em.GetIntensity()); 
    182                         } 
    183                 } else if (em.getType().equalsIgnoreCase 
    184  
    185                 (OCCEmotionType.DISTRESS.name())) { 
    186                         if (em.GetCause().GetTarget() != null && 
    187  
    188                         em.GetCause().GetTarget().equals(Constants.SELF)) { 
    189                                 LikeRelation.getRelation 
    190  
    191                                 (Constants.SELF, em.GetCause().GetSubject()).decrement(m, 
    192  
    193                                 em.GetIntensity()); 
    194                         } 
    195                 } 
    196         } 
    197  
    198         @Override 
    199         public IComponent createModelOfOther() { 
    200                 return new SocialRelationsComponent(new ArrayList<String>()); 
    201         } 
    202  
    203         @Override 
    204         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    205                 return new SocialRelationsPanel(); 
     198        public String name() { 
     199                return SocialRelationsComponent.NAME; 
    206200        } 
    207201 
     
    210204                return null; 
    211205        } 
     206 
     207        @Override 
     208        public void reset() { 
     209        } 
     210 
     211        @Override 
     212        public void update(AgentModel am, Event e) { 
     213        } 
     214         
     215        @Override 
     216        public void update(AgentModel am, long time) { 
     217        } 
    212218} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.ToM/src/FAtiMA/ToM/ToMComponent.java

    r970 r972  
    2424import FAtiMA.DeliberativeComponent.strategies.IGetUtilityForOthers; 
    2525import FAtiMA.OCCAffectDerivation.OCCAppraisalVariables; 
     26import FAtiMA.ReactiveComponent.ReactiveComponent; 
    2627 
    2728public class ToMComponent implements Serializable, IAppraisalDerivationComponent, IAdvancedPerceptionsComponent, IGetModelStrategy, IGetUtilityForOthers { 
     
    5253                        this._nearbyAgents.add(agent); 
    5354                } 
    54         } 
    55          
    56         private boolean isPerson(AgentCore ag, String agent) 
    57         { 
    58                 Name isPerson = Name.ParseName(agent + "(isPerson)"); 
    59                 return ag.getMemory().getSemanticMemory().AskPredicate(isPerson); 
    60         } 
    61          
    62         public HashMap<String,ModelOfOther> getToM() 
    63         { 
    64                 return this._ToM; 
    65         } 
    66  
    67         @Override 
    68         public String name() { 
    69                 return ToMComponent.NAME; 
    70         } 
    71  
    72         @Override 
    73         public void initialize(AgentModel am) { 
    74                 DeliberativeComponent dc = (DeliberativeComponent) am.getComponent(DeliberativeComponent.NAME); 
    75                 am.setModelStrategy(this); 
    76                 Plan.setDetectThreatStrategy(new DetectThreatStrategy()); 
    77                 dc.setUtilityForOthersStrategy(this); 
    7855        } 
    7956         
     
    9875        } 
    9976         
    100         public void RemoveNearByAgent(String entity) 
    101         { 
    102                 this._nearbyAgents.remove(entity); 
    103         } 
    104  
    105         @Override 
    106         public void reset() { 
    107                 // TODO Auto-generated method stub 
    108         } 
    109  
    110         @Override 
    111         public void update(AgentModel am,long time) { 
    112                  
    113                 for(String s : _nearbyAgents) 
    114                 { 
    115                         ModelOfOther m = _ToM.get(s); 
    116                         m.update(time); 
    117                 }                
    118         } 
    119          
    120         @Override 
    121         public void update(AgentModel am, Event e) 
    122         { 
    123                 Event e2 = e.RemovePerspective(_name); 
    124                 Event e3; 
    125                 for(String s : _nearbyAgents) 
    126                 { 
    127                         ModelOfOther m = _ToM.get(s); 
    128                         e3 = e2.ApplyPerspective(s); 
    129                         m.update(e3); 
    130                 }                
     77        private boolean isPerson(AgentCore ag, String agent) 
     78        { 
     79                Name isPerson = Name.ParseName(agent + "(isPerson)"); 
     80                return ag.getMemory().getSemanticMemory().AskPredicate(isPerson); 
     81        } 
     82 
     83        @Override 
     84        public void actionFailedPerception(Event e) { 
     85                // TODO Auto-generated method stub       
    13186        } 
    13287 
     
    159114        } 
    160115         
     116        @Override 
     117        public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
     118                return new ToMPanel(this); 
     119        } 
     120         
     121        @Override 
     122        public void entityRemovedPerception(String entity) { 
     123                _nearbyAgents.remove(entity); 
     124        } 
     125 
    161126        public AgentModel execute(Symbol ToM) 
    162127        { 
     
    172137 
    173138        @Override 
    174         public void propertyChangedPerception(String ToM, Name propertyName, String value)  
    175         { 
    176                 Name propertyName2 = AgentCore.removePerspective(propertyName, _name); 
    177                  
    178                 if(ToM.equals(Constants.UNIVERSAL.toString())) 
    179                 { 
    180                         for(String other : _nearbyAgents) 
    181                         { 
    182                                 ModelOfOther m = _ToM.get(other); 
    183                                 m.getMemory().getSemanticMemory().Tell(AgentCore.applyPerspective(propertyName2,other), value); 
    184                         } 
    185                 } 
    186                 else if(!ToM.equals(_name)) 
    187                 { 
    188                         ModelOfOther m = _ToM.get(ToM); 
    189                         if(m != null) 
    190                         { 
    191                                 m.getMemory().getSemanticMemory().Tell(AgentCore.applyPerspective(propertyName2,ToM), value); 
    192                         } 
    193                 } 
    194                  
     139        public String[] getComponentDependencies() { 
     140                String[] dependencies = {ReactiveComponent.NAME,DeliberativeComponent.NAME}; 
     141                return dependencies; 
     142        } 
     143         
     144        public HashMap<String,ModelOfOther> getToM() 
     145        { 
     146                return this._ToM; 
     147        } 
     148 
     149        @Override 
     150        public float getUtilityForOthers(AgentModel am, ActivePursuitGoal g) { 
     151                DeliberativeComponent dp = (DeliberativeComponent) am.getComponent(DeliberativeComponent.NAME); 
     152                 
     153                float utility = 0; 
     154                 
     155                for(ModelOfOther m : _ToM.values()) 
     156                { 
     157                        utility+= dp.getUtilityStrategy().getUtility(m, g); 
     158                } 
     159                 
     160                return utility; 
     161        } 
     162         
     163        @Override 
     164        public void initialize(AgentModel am) { 
     165                DeliberativeComponent dc = (DeliberativeComponent) am.getComponent(DeliberativeComponent.NAME); 
     166                am.setModelStrategy(this); 
     167                Plan.setDetectThreatStrategy(new DetectThreatStrategy()); 
     168                dc.setUtilityForOthersStrategy(this); 
     169        } 
     170 
     171        @Override 
     172        public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
    195173        } 
    196174 
     
    234212 
    235213        @Override 
    236         public void entityRemovedPerception(String entity) { 
    237                 _nearbyAgents.remove(entity); 
    238         } 
    239  
    240         @Override 
    241         public AgentDisplayPanel createDisplayPanel(AgentModel am) { 
    242                 return new ToMPanel(this); 
    243         } 
    244  
    245         @Override 
    246         public float getUtilityForOthers(AgentModel am, ActivePursuitGoal g) { 
    247                 DeliberativeComponent dp = (DeliberativeComponent) am.getComponent(DeliberativeComponent.NAME); 
    248                  
    249                 float utility = 0; 
    250                  
    251                 for(ModelOfOther m : _ToM.values()) 
    252                 { 
    253                         utility+= dp.getUtilityStrategy().getUtility(m, g); 
    254                 } 
    255                  
    256                 return utility; 
     214        public String name() { 
     215                return ToMComponent.NAME; 
     216        } 
     217 
     218        @Override 
     219        public void propertyChangedPerception(String ToM, Name propertyName, String value)  
     220        { 
     221                Name propertyName2 = AgentCore.removePerspective(propertyName, _name); 
     222                 
     223                if(ToM.equals(Constants.UNIVERSAL.toString())) 
     224                { 
     225                        for(String other : _nearbyAgents) 
     226                        { 
     227                                ModelOfOther m = _ToM.get(other); 
     228                                m.getMemory().getSemanticMemory().Tell(AgentCore.applyPerspective(propertyName2,other), value); 
     229                        } 
     230                } 
     231                else if(!ToM.equals(_name)) 
     232                { 
     233                        ModelOfOther m = _ToM.get(ToM); 
     234                        if(m != null) 
     235                        { 
     236                                m.getMemory().getSemanticMemory().Tell(AgentCore.applyPerspective(propertyName2,ToM), value); 
     237                        } 
     238                } 
     239                 
    257240        } 
    258241 
     
    262245        } 
    263246 
    264         @Override 
    265         public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
    266         } 
    267  
    268         @Override 
    269         public void actionFailedPerception(Event e) { 
     247        public void RemoveNearByAgent(String entity) 
     248        { 
     249                this._nearbyAgents.remove(entity); 
     250        } 
     251 
     252        @Override 
     253        public void reset() { 
    270254                // TODO Auto-generated method stub 
    271                  
     255        } 
     256 
     257        @Override 
     258        public void update(AgentModel am, Event e) 
     259        { 
     260                Event e2 = e.RemovePerspective(_name); 
     261                Event e3; 
     262                for(String s : _nearbyAgents) 
     263                { 
     264                        ModelOfOther m = _ToM.get(s); 
     265                        e3 = e2.ApplyPerspective(s); 
     266                        m.update(e3); 
     267                }                
     268        } 
     269         
     270        @Override 
     271        public void update(AgentModel am,long time) { 
     272                 
     273                for(String s : _nearbyAgents) 
     274                { 
     275                        ModelOfOther m = _ToM.get(s); 
     276                        m.update(time); 
     277                }                
    272278        } 
    273279} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA.culture/src/FAtiMA/culture/CulturalDimensionsComponent.java

    r970 r972  
    2929import FAtiMA.DeliberativeComponent.strategies.IGetUtilityForOthers; 
    3030import FAtiMA.OCCAffectDerivation.OCCAppraisalVariables; 
     31import FAtiMA.ReactiveComponent.ReactiveComponent; 
    3132 
    3233 
     
    361362        @Override 
    362363        public void inverseAppraisal(AgentModel am, AppraisalFrame af) { 
     364        } 
     365 
     366        @Override 
     367        public String[] getComponentDependencies() { 
     368                String[] dependencies = {ReactiveComponent.NAME,DeliberativeComponent.NAME}; 
     369                return dependencies; 
    363370        }        
    364371} 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/AgentCore.java

    r970 r972  
    3939import FAtiMA.Core.exceptions.ActionsParsingException; 
    4040import FAtiMA.Core.exceptions.GoalLibParsingException; 
     41import FAtiMA.Core.exceptions.RequiredComponentException; 
    4142import FAtiMA.Core.exceptions.UndefinedComponentException; 
    4243import FAtiMA.Core.exceptions.UnknownGoalException; 
     
    297298        public void addComponent(IComponent c) 
    298299        { 
     300                for(String dependency : c.getComponentDependencies()){ 
     301                        if (!this._generalComponents.containsKey(dependency)) 
     302                                throw new RequiredComponentException(c.name(),dependency); 
     303                } 
     304                         
     305                 
    299306                this._generalComponents.put(c.name(), c); 
    300307                if(c instanceof IProcessEmotionComponent) 
  • AgentMind/branches/FAtiMA-Modular/FAtiMA/src/FAtiMA/Core/componentTypes/IComponent.java

    r926 r972  
    1919        public AgentDisplayPanel createDisplayPanel(AgentModel am); 
    2020         
     21        public String[] getComponentDependencies(); 
     22         
    2123} 
Note: See TracChangeset for help on using the changeset viewer.