Changeset 211


Ignore:
Timestamp:
11/13/2009 10:58:44 AM (10 years ago)
Author:
joao.dias
Message:

Solved a problem with adding null emotions to the emotional state.

Added the display of the ToM components of other agents to the swing display (still incomplete though)

Location:
AgentMind/branches/FAtiMA2/src/FAtiMA
Files:
3 added
13 edited

Legend:

Unmodified
Added
Removed
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Agent.java

    r210 r211  
    285285        } 
    286286         
    287         private void loadPersonality(String personalityFile, short agentPlatform, ArrayList<String> goalList)  
    288                 throws  ParserConfigurationException, SAXException, IOException, UnknownGoalException{ 
    289                  
    290                 AgentLogger.GetInstance().log("LOADING Personality: " + personalityFile); 
    291                 AgentLoaderHandler c = new AgentLoaderHandler(this,_reactiveLayer,_deliberativeLayer,_emotionalState); 
    292  
    293                 SAXParserFactory factory = SAXParserFactory.newInstance(); 
    294                 SAXParser parser = factory.newSAXParser(); 
    295                 parser.parse(new File(personalityFile), c); 
    296  
    297                 //The ION Agent does not load the goals initially from the personality file, therefore we 
    298                 //must clear all the goals loaded. 
    299                 if(agentPlatform == AgentPlatform.ION){ 
    300                         _deliberativeLayer.RemoveAllGoals(); 
    301                 } 
    302  
    303                 //The WorldSimulator Agent loads additional goals provided in the starting goal list 
    304                 if(agentPlatform == AgentPlatform.WORLDSIM){ 
    305                         ListIterator<String> lt = goalList.listIterator(); 
    306                         String goal; 
    307                         String goalName; 
    308                         StringTokenizer st; 
    309                         float impOfSuccess; 
    310                         float impOfFailure; 
    311                         while(lt.hasNext()) { 
    312                                 goal = (String) lt.next(); 
    313                                 st = new StringTokenizer(goal, "|"); 
    314                                 goalName = st.nextToken(); 
    315                                 impOfSuccess = Float.parseFloat(st.nextToken()); 
    316                                 impOfFailure = Float.parseFloat(st.nextToken()); 
    317  
    318                                 _deliberativeLayer.AddGoal(this, goalName, impOfSuccess, impOfFailure);    
    319                         }        
    320                 } 
    321         } 
    322          
    323         private void loadCulture(String cultureName) 
    324                 throws ParserConfigurationException, SAXException, IOException{ 
    325  
    326                 AgentLogger.GetInstance().log("LOADING Culture: " + cultureName); 
    327                  
    328                 CultureLoaderHandler culture = new CultureLoaderHandler(this, _reactiveLayer,_deliberativeLayer); 
    329                 SAXParserFactory factory = SAXParserFactory.newInstance(); 
    330                 SAXParser parser = factory.newSAXParser(); 
    331                 parser.parse(new File(MIND_PATH + cultureName + ".xml"), culture); 
    332                  
    333                 Ritual r; 
    334                 ListIterator<Ritual> li = culture.GetRituals(this).listIterator(); 
    335                 while(li.hasNext()) 
    336                 { 
    337                         r = (Ritual) li.next(); 
    338                         _deliberativeLayer.AddRitual(r); 
    339                         _deliberativeLayer.AddGoal(r); 
    340                         AgentLogger.GetInstance().log("Ritual: "+ r.toString()); 
    341                 } 
    342                  
    343                 CulturalDimensions.GetInstance().changeNeedsWeightsAndDecays(this); 
    344         } 
    345          
    346          
    347  
    348         public void SaveAgentState(String agentName) 
    349         { 
    350                 String fileName = _saveDirectory + agentName; 
    351  
    352                 AgentSimulationTime.SaveState(fileName+"-Timer.dat"); 
    353                 ActionLibrary.SaveState(fileName+"-ActionLibrary.dat"); 
    354                 _remoteAgent.SaveState(fileName+"-RemoteAgent.dat"); 
    355  
    356                 try 
    357                 { 
    358                         FileOutputStream out = new FileOutputStream(fileName); 
    359                         ObjectOutputStream s = new ObjectOutputStream(out); 
    360  
    361                         s.writeObject(_ToM); 
    362                         s.writeObject(_deliberativeLayer); 
    363                         s.writeObject(_reactiveLayer); 
    364                         s.writeObject(_emotionalState); 
    365                         s.writeObject(_memory); 
    366                         s.writeObject(_motivationalState); 
    367                         s.writeObject(_dialogManager); 
    368                         s.writeObject(_role); 
    369                         s.writeObject(_name); 
    370                         s.writeObject(_sex); 
    371                         s.writeObject(_speechAct); 
    372                         s.writeObject(new Short(_currentEmotion)); 
    373                         s.writeObject(_displayName); 
    374                         s.writeObject(new Boolean(_showStateWindow)); 
    375                         s.writeObject(_actionsForExecution); 
    376                         s.writeObject(_perceivedEvents); 
    377                         s.writeObject(_saveDirectory); 
    378                         s.flush(); 
    379                         s.close(); 
    380                         out.close(); 
    381                 } 
    382                 catch(Exception e) 
    383                 { 
    384                         e.printStackTrace(); 
     287        /** 
     288         * Specifies that the agent must give an answer to a received 
     289         * SpeechAct 
     290         * @param speechAct - the SpeechAct that needs an answer  
     291         */ 
     292        public void AnswerToSpeechAct(SpeechAct speechAct) { 
     293            _speechAct = speechAct; 
     294        } 
     295         
     296        public void AppraiseSelfActionFailed(Event e) 
     297        { 
     298                _deliberativeLayer.AppraiseSelfActionFailed(e); 
     299        } 
     300         
     301         
     302 
     303        /** 
     304         * Gets the agent's name that is displayed externally 
     305         * @return the agent's external name 
     306         */ 
     307        public String displayName() { 
     308            return _displayName; 
     309        } 
     310         
     311        public void EnforceCopingStrategy(String coping) 
     312        { 
     313                _deliberativeLayer.EnforceCopingStrategy(this, coping); 
     314                _reactiveLayer.EnforceCopingStrategy(coping); 
     315        } 
     316         
     317        private ValuedAction FilterSpeechAction(ValuedAction action) 
     318        { 
     319                ValuedAction aux=null; 
     320                 
     321                if(action != null) 
     322                { 
     323                        String actionName = action.GetAction().GetFirstLiteral().toString(); 
     324                        if(_dialogManager.CanSpeak() || !SpeechAct.isSpeechAct(actionName)) 
     325                        { 
     326                                aux = action; 
     327                        } 
     328                } 
     329                 
     330                return aux; 
     331        } 
     332 
     333        /** 
     334         * Gets the agent's Deliberative Layer that you can use 
     335         * to get access to Deliberative structures such as  
     336         * the goals and planner 
     337         * @return the agent's Deliberative Layer 
     338         */ 
     339        public DeliberativeProcess getDeliberativeLayer() 
     340        { 
     341                return this._deliberativeLayer; 
     342        } 
     343         
     344        public EmotionalState getEmotionalState() 
     345        { 
     346                return _emotionalState; 
     347        } 
     348         
     349        public Memory getMemory() 
     350        { 
     351                return _memory; 
     352        } 
     353         
     354        public MotivationalState getMotivationalState() 
     355        { 
     356                return _motivationalState; 
     357        } 
     358         
     359        /** 
     360         * Gets the name of the agent 
     361         * @return the agent's name 
     362         */ 
     363        public String getName() { 
     364                return _name; 
     365        } 
     366         
     367        /** 
     368         * Gets the agent's Reactive Layer that you can use 
     369         * to get access to reactive structures such as  
     370         * ActionTendencies and  EmotionalReactions 
     371         * @return the agent's Reactive Layer 
     372         */ 
     373        public ReactiveProcess getReactiveLayer() 
     374        { 
     375                return this._reactiveLayer; 
     376        } 
     377         
     378        public HashMap<String,ModelOfOther> getToM() 
     379        { 
     380                return this._ToM; 
     381        } 
     382         
     383        public void initializeModelOfOther(String name) 
     384        { 
     385                if(!_ToM.containsKey(name)) 
     386                { 
     387                        ModelOfOther model = new ModelOfOther(name, _reactiveLayer.getEmotionalReactions(), _reactiveLayer.getActionTendencies()); 
     388                        _ToM.put(name, model); 
    385389                } 
    386390        } 
     
    419423        } 
    420424         
    421         private void terminateExecution(){ 
    422                 _deliberativeLayer.ShutDown(); 
    423                 _reactiveLayer.ShutDown(); 
    424                 _remoteAgent.ShutDown(); 
    425                 if(_showStateWindow && _agentDisplay != null) _agentDisplay.dispose(); 
    426         } 
    427  
    428         /** 
    429          * Gets the name of the agent 
    430          * @return the agent's name 
    431          */ 
    432         public String getName() { 
    433                 return _name; 
    434         } 
    435          
    436         /** 
    437          * Gets the gender of the agent 
    438          * @return the agent's sex 
    439          */ 
    440         public String sex()  
    441         { 
    442                 return _sex; 
    443         } 
    444          
    445         /** 
    446          * Gets the agent's name that is displayed externally 
    447          * @return the agent's external name 
    448          */ 
    449         public String displayName() { 
    450             return _displayName; 
    451         } 
    452          
    453         public EmotionalState getEmotionalState() 
    454         { 
    455                 return _emotionalState; 
    456         } 
    457          
    458         public Memory getMemory() 
    459         { 
    460                 return _memory; 
    461         } 
    462          
    463         public MotivationalState getMotivationalState() 
    464         { 
    465                 return _motivationalState; 
    466         } 
    467          
    468         /** 
    469          * Gets the agent's Reactive Layer that you can use 
    470          * to get access to reactive structures such as  
    471          * ActionTendencies and  EmotionalReactions 
    472          * @return the agent's Reactive Layer 
    473          */ 
    474         public ReactiveProcess getReactiveLayer() 
    475         { 
    476                 return this._reactiveLayer; 
    477         } 
    478          
    479         /** 
    480          * Gets the agent's Deliberative Layer that you can use 
    481          * to get access to Deliberative structures such as  
    482          * the goals and planner 
    483          * @return the agent's Deliberative Layer 
    484          */ 
    485         public DeliberativeProcess getDeliberativeLayer() 
    486         { 
    487                 return this._deliberativeLayer; 
    488         } 
    489          
    490         /** 
    491          * Specifies that the agent must give an answer to a received 
    492          * SpeechAct 
    493          * @param speechAct - the SpeechAct that needs an answer  
    494          */ 
    495         public void AnswerToSpeechAct(SpeechAct speechAct) { 
    496             _speechAct = speechAct; 
     425        private void loadCulture(String cultureName) 
     426                throws ParserConfigurationException, SAXException, IOException{ 
     427 
     428                AgentLogger.GetInstance().log("LOADING Culture: " + cultureName); 
     429                 
     430                CultureLoaderHandler culture = new CultureLoaderHandler(this, _reactiveLayer,_deliberativeLayer); 
     431                SAXParserFactory factory = SAXParserFactory.newInstance(); 
     432                SAXParser parser = factory.newSAXParser(); 
     433                parser.parse(new File(MIND_PATH + cultureName + ".xml"), culture); 
     434                 
     435                Ritual r; 
     436                ListIterator<Ritual> li = culture.GetRituals(this).listIterator(); 
     437                while(li.hasNext()) 
     438                { 
     439                        r = (Ritual) li.next(); 
     440                        _deliberativeLayer.AddRitual(r); 
     441                        _deliberativeLayer.AddGoal(r); 
     442                        AgentLogger.GetInstance().log("Ritual: "+ r.toString()); 
     443                } 
     444                 
     445                CulturalDimensions.GetInstance().changeNeedsWeightsAndDecays(this); 
     446        } 
     447         
     448        private void loadPersonality(String personalityFile, short agentPlatform, ArrayList<String> goalList)  
     449                throws  ParserConfigurationException, SAXException, IOException, UnknownGoalException{ 
     450                 
     451                AgentLogger.GetInstance().log("LOADING Personality: " + personalityFile); 
     452                AgentLoaderHandler c = new AgentLoaderHandler(this,_reactiveLayer,_deliberativeLayer,_emotionalState); 
     453 
     454                SAXParserFactory factory = SAXParserFactory.newInstance(); 
     455                SAXParser parser = factory.newSAXParser(); 
     456                parser.parse(new File(personalityFile), c); 
     457 
     458                //The ION Agent does not load the goals initially from the personality file, therefore we 
     459                //must clear all the goals loaded. 
     460                if(agentPlatform == AgentPlatform.ION){ 
     461                        _deliberativeLayer.RemoveAllGoals(); 
     462                } 
     463 
     464                //The WorldSimulator Agent loads additional goals provided in the starting goal list 
     465                if(agentPlatform == AgentPlatform.WORLDSIM){ 
     466                        ListIterator<String> lt = goalList.listIterator(); 
     467                        String goal; 
     468                        String goalName; 
     469                        StringTokenizer st; 
     470                        float impOfSuccess; 
     471                        float impOfFailure; 
     472                        while(lt.hasNext()) { 
     473                                goal = (String) lt.next(); 
     474                                st = new StringTokenizer(goal, "|"); 
     475                                goalName = st.nextToken(); 
     476                                impOfSuccess = Float.parseFloat(st.nextToken()); 
     477                                impOfFailure = Float.parseFloat(st.nextToken()); 
     478 
     479                                _deliberativeLayer.AddGoal(this, goalName, impOfSuccess, impOfFailure);    
     480                        }        
     481                } 
    497482        } 
    498483         
     
    508493                } 
    509494        } 
     495         
     496        public void PerceivePropertyChanged(Name propertyName, String value) 
     497        { 
     498                ArrayList<Symbol> symbols; 
     499                symbols = propertyName.GetLiteralList(); 
     500                 
     501                //I'm changing directly the received name; not a good thing to do 
     502                for(int i = 0; i < symbols.size(); i++) 
     503                { 
     504                        if(symbols.get(i).getName().equals(_name)) 
     505                        { 
     506                                symbols.set(i, new Symbol(Constants.SELF)); 
     507                        } 
     508                } 
     509                 
     510                _memory.getSemanticMemory().Tell(propertyName, value); 
     511        } 
     512 
     513        public void PerceivePropertyChanged(String subject, String property, String value) 
     514        { 
     515                if(subject.equals(_name)) 
     516                { 
     517                        subject = Constants.SELF; 
     518                } 
     519                 
     520                Name propertyName = Name.ParseName(subject + "(" + property + ")"); 
     521                _memory.getSemanticMemory().Tell(propertyName, value); 
     522        } 
     523         
     524        public void PerceivePropertyRemoved(String subject, String property) 
     525        { 
     526                if(subject.equals(_name)) 
     527                { 
     528                        subject = Constants.SELF; 
     529                } 
     530                 
     531                Name propertyName = Name.ParseName(subject + "(" + property + ")"); 
     532                _memory.getSemanticMemory().Retract(propertyName); 
     533                 
     534        } 
     535         
     536         
    510537         
    511538        /** 
     
    528555                return _role; 
    529556        } 
    530  
     557         
    531558        /** 
    532559         * Runs the agent, endless loop until there is a shutdown 
     
    678705        } 
    679706         
    680         public void initializeModelOfOther(String name) 
    681         { 
    682                 if(!_ToM.containsKey(name)) 
    683                 { 
    684                         ModelOfOther model = new ModelOfOther(name, _reactiveLayer.getEmotionalReactions(), _reactiveLayer.getActionTendencies()); 
    685                         _ToM.put(name, model); 
    686                 } 
    687         } 
    688          
    689          
    690          
    691         private ValuedAction FilterSpeechAction(ValuedAction action) 
    692         { 
    693                 ValuedAction aux=null; 
    694                  
    695                 if(action != null) 
    696                 { 
    697                         String actionName = action.GetAction().GetFirstLiteral().toString(); 
    698                         if(_dialogManager.CanSpeak() || !SpeechAct.isSpeechAct(actionName)) 
     707        public void SaveAgentState(String agentName) 
     708        { 
     709                String fileName = _saveDirectory + agentName; 
     710 
     711                AgentSimulationTime.SaveState(fileName+"-Timer.dat"); 
     712                ActionLibrary.SaveState(fileName+"-ActionLibrary.dat"); 
     713                _remoteAgent.SaveState(fileName+"-RemoteAgent.dat"); 
     714 
     715                try 
     716                { 
     717                        FileOutputStream out = new FileOutputStream(fileName); 
     718                        ObjectOutputStream s = new ObjectOutputStream(out); 
     719 
     720                        s.writeObject(_ToM); 
     721                        s.writeObject(_deliberativeLayer); 
     722                        s.writeObject(_reactiveLayer); 
     723                        s.writeObject(_emotionalState); 
     724                        s.writeObject(_memory); 
     725                        s.writeObject(_motivationalState); 
     726                        s.writeObject(_dialogManager); 
     727                        s.writeObject(_role); 
     728                        s.writeObject(_name); 
     729                        s.writeObject(_sex); 
     730                        s.writeObject(_speechAct); 
     731                        s.writeObject(new Short(_currentEmotion)); 
     732                        s.writeObject(_displayName); 
     733                        s.writeObject(new Boolean(_showStateWindow)); 
     734                        s.writeObject(_actionsForExecution); 
     735                        s.writeObject(_perceivedEvents); 
     736                        s.writeObject(_saveDirectory); 
     737                        s.flush(); 
     738                        s.close(); 
     739                        out.close(); 
     740                } 
     741                catch(Exception e) 
     742                { 
     743                        e.printStackTrace(); 
     744                } 
     745        } 
     746         
     747         
     748        protected ValuedAction SelectBestAction() { 
     749                 
     750                ValuedAction bestAction = null; 
     751                ValuedAction action; 
     752                int removeHere=-1; 
     753                 
     754                for(int i=0; i < _actionsForExecution.size(); i++) 
     755                { 
     756                        action = (ValuedAction) _actionsForExecution.get(i); 
     757                        if(bestAction == null || action.GetValue(_emotionalState) > bestAction.GetValue(_emotionalState)) 
    699758                        { 
    700                                 aux = action; 
    701                         } 
    702                 } 
    703                  
    704                 return aux; 
    705         } 
    706          
    707         public void AppraiseSelfActionFailed(Event e) 
    708         { 
    709                 _deliberativeLayer.AppraiseSelfActionFailed(e); 
    710         } 
    711          
    712         public void SpeechStarted() 
    713         { 
    714                 _dialogManager.SpeechStarted(); 
     759                                bestAction = action; 
     760                                removeHere = i; 
     761                        } 
     762                } 
     763                 
     764                if(bestAction != null) 
     765                { 
     766                        _actionsForExecution.remove(removeHere); 
     767                } 
     768                return bestAction; 
     769        } 
     770         
     771        /** 
     772         * Gets the gender of the agent 
     773         * @return the agent's sex 
     774         */ 
     775        public String sex()  
     776        { 
     777                return _sex; 
    715778        } 
    716779         
     
    766829        } 
    767830         
    768          
    769         protected ValuedAction SelectBestAction() { 
    770                  
    771                 ValuedAction bestAction = null; 
    772                 ValuedAction action; 
    773                 int removeHere=-1; 
    774                  
    775                 for(int i=0; i < _actionsForExecution.size(); i++) 
    776                 { 
    777                         action = (ValuedAction) _actionsForExecution.get(i); 
    778                         if(bestAction == null || action.GetValue(_emotionalState) > bestAction.GetValue(_emotionalState)) 
    779                         { 
    780                                 bestAction = action; 
    781                                 removeHere = i; 
    782                         } 
    783                 } 
    784                  
    785                 if(bestAction != null) 
    786                 { 
    787                         _actionsForExecution.remove(removeHere); 
    788                 } 
    789                 return bestAction; 
    790         } 
    791          
    792         public void EnforceCopingStrategy(String coping) 
    793         { 
    794                 _deliberativeLayer.EnforceCopingStrategy(this, coping); 
    795                 _reactiveLayer.EnforceCopingStrategy(coping); 
    796         } 
    797          
    798         public void PerceivePropertyChanged(String subject, String property, String value) 
    799         { 
    800                 if(subject.equals(_name)) 
    801                 { 
    802                         subject = Constants.SELF; 
    803                 } 
    804                  
    805                 Name propertyName = Name.ParseName(subject + "(" + property + ")"); 
    806                 _memory.getSemanticMemory().Tell(propertyName, value); 
    807         } 
    808          
    809         public void PerceivePropertyChanged(Name propertyName, String value) 
    810         { 
    811                 ArrayList<Symbol> symbols; 
    812                 symbols = propertyName.GetLiteralList(); 
    813                  
    814                 //I'm changing directly the received name; not a good thing to do 
    815                 for(int i = 0; i < symbols.size(); i++) 
    816                 { 
    817                         if(symbols.get(i).getName().equals(_name)) 
    818                         { 
    819                                 symbols.set(i, new Symbol(Constants.SELF)); 
    820                         } 
    821                 } 
    822                  
    823                 _memory.getSemanticMemory().Tell(propertyName, value); 
    824         } 
    825          
    826          
    827          
    828         public void PerceivePropertyRemoved(String subject, String property) 
    829         { 
    830                 if(subject.equals(_name)) 
    831                 { 
    832                         subject = Constants.SELF; 
    833                 } 
    834                  
    835                 Name propertyName = Name.ParseName(subject + "(" + property + ")"); 
    836                 _memory.getSemanticMemory().Retract(propertyName); 
    837                  
     831        public void SpeechStarted() 
     832        { 
     833                _dialogManager.SpeechStarted(); 
     834        } 
     835         
     836         
     837         
     838        private void terminateExecution(){ 
     839                _deliberativeLayer.ShutDown(); 
     840                _reactiveLayer.ShutDown(); 
     841                _remoteAgent.ShutDown(); 
     842                if(_showStateWindow && _agentDisplay != null) _agentDisplay.dispose(); 
    838843        } 
    839844 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/AgentDisplay.java

    r209 r211  
    8787                panel = new ShortTermMemoryPanel(); 
    8888                _displayPane.addTab("Short Term Memory", null, panel, "displays all the records in the character's short term memory"); 
     89                 
     90                panel = new ToMPanel(); 
     91                _displayPane.addTab("Theory of Mind",null, panel, "displays the ToM (memory, emotional state,etc) of the other agent's"); 
    8992         
    9093                 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/AgentDisplayPanel.java

    r191 r211  
    3434 
    3535import FAtiMA.Agent; 
     36import FAtiMA.AgentModel; 
    3637 
    3738 
     
    4344        private static final long serialVersionUID = 1L; 
    4445 
    45         public abstract boolean Update(Agent ag);  
     46        public abstract boolean Update(Agent ag); 
     47         
     48        public abstract boolean Update(AgentModel am); 
    4649 
    4750} 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/EmotionalStatePanel.java

    r191 r211  
    4343 
    4444import FAtiMA.Agent; 
     45import FAtiMA.AgentModel; 
    4546import FAtiMA.emotionalState.ActiveEmotion; 
    4647import FAtiMA.emotionalState.EmotionalState; 
     
    99100    } 
    100101     
    101     public boolean Update(Agent ag) { 
     102    public boolean Update(Agent ag) 
     103    { 
     104        return Update((AgentModel) ag); 
     105    } 
     106     
     107    public boolean Update(AgentModel am) { 
    102108        Float aux; 
    103109        ActiveEmotion em; 
    104         EmotionalState es = ag.getEmotionalState(); 
     110        EmotionalState es = am.getEmotionalState(); 
    105111         
    106112        //aux = new Float(es.GetArousal()); 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/EpisodicMemoryPanel.java

    r198 r211  
    4141 
    4242import FAtiMA.Agent; 
     43import FAtiMA.AgentModel; 
    4344import FAtiMA.memory.episodicMemory.MemoryEpisode; 
    4445 
     
    7273    } 
    7374     
     75    public boolean Update(Agent ag) 
     76    { 
     77        return Update((AgentModel) ag); 
     78    } 
    7479     
    75     public boolean Update(Agent ag) { 
     80     
     81    public boolean Update(AgentModel am) { 
    7682         
    7783        boolean update = false; 
    7884         
    79         if(countMemoryDetails() != ag.getMemory().getEpisodicMemory().countMemoryDetails()) { 
     85        if(countMemoryDetails() != am.getMemory().getEpisodicMemory().countMemoryDetails()) { 
    8086                update = true; 
    8187                _memoryEpisodes.removeAll(); 
     
    8389                 
    8490                 
    85                 synchronized(ag.getMemory().getEpisodicMemory().GetSyncRoot()){ 
    86                         Iterator<MemoryEpisode> it = ag.getMemory().getEpisodicMemory().GetAllEpisodes().iterator(); 
     91                synchronized(am.getMemory().getEpisodicMemory().GetSyncRoot()){ 
     92                        Iterator<MemoryEpisode> it = am.getMemory().getEpisodicMemory().GetAllEpisodes().iterator(); 
    8793                MemoryEpisodeDisplay mDisplay; 
    8894                MemoryEpisode episode; 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/GoalsPanel.java

    r191 r211  
    4141 
    4242import FAtiMA.Agent; 
     43import FAtiMA.AgentModel; 
    4344import FAtiMA.deliberativeLayer.DeliberativeProcess; 
    4445import FAtiMA.deliberativeLayer.Intention; 
     
    8586                 
    8687                this.add(intentionsScroll); 
     88    } 
     89     
     90    public boolean Update(AgentModel am) 
     91    { 
     92        return false; 
    8793    } 
    8894     
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/KnowledgeBasePanel.java

    r198 r211  
    3939 
    4040import FAtiMA.Agent; 
     41import FAtiMA.AgentModel; 
    4142import FAtiMA.memory.semanticMemory.KnowledgeSlot; 
    4243 
     
    6970                 
    7071    } 
     72     
     73    public boolean Update(Agent ag) 
     74    { 
     75        return Update((AgentModel)ag); 
     76    } 
    7177    
    72     public boolean Update(Agent ag) { 
     78    public boolean Update(AgentModel am) { 
    7379         
    74         ListIterator<KnowledgeSlot> li = ag.getMemory().getSemanticMemory().GetFactList(); 
     80        ListIterator<KnowledgeSlot> li = am.getMemory().getSemanticMemory().GetFactList(); 
    7581         
    7682        KnowledgeSlot slot; 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/NeedsPanel.java

    r209 r211  
    5050        } 
    5151         
     52        public boolean Update(Agent ag) 
     53        { 
     54                return Update((AgentModel) ag); 
     55        } 
    5256         
    53         public boolean Update(Agent ag) { 
     57         
     58        public boolean Update(AgentModel ag) { 
    5459 
    5560                CheckForOtherAgents(ag); 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/ShortTermMemoryPanel.java

    r198 r211  
    4141 
    4242import FAtiMA.Agent; 
     43import FAtiMA.AgentModel; 
    4344import FAtiMA.memory.semanticMemory.KnowledgeSlot; 
    4445import FAtiMA.memory.semanticMemory.SemanticMemory; 
     
    123124    } 
    124125     
     126    public boolean Update(Agent ag) 
     127    { 
     128        return Update((AgentModel) ag); 
     129    } 
    125130     
    126     public boolean Update(Agent ag) { 
     131    public boolean Update(AgentModel am) { 
    127132         
    128133        _memoryRecords.removeAll(); 
    129134                 
    130135        //EpisodicMemory em = ag.getMemory().getEpisodicMemory(); 
    131         SemanticMemory sm = ag.getMemory().getSemanticMemory(); 
     136        SemanticMemory sm = am.getMemory().getSemanticMemory(); 
    132137                 
    133         _stmRecordDisplay = new STMRecordDisplay(ag); 
     138        _stmRecordDisplay = new STMRecordDisplay(am); 
    134139        _memoryRecords.add(_stmRecordDisplay.getSTMRecordPanel());       
    135140      
  • AgentMind/branches/FAtiMA2/src/FAtiMA/Display/SocialRelationsPanel.java

    r191 r211  
    1111 
    1212import FAtiMA.Agent; 
     13import FAtiMA.AgentModel; 
    1314import FAtiMA.socialRelations.LikeRelation; 
    1415import FAtiMA.socialRelations.Relation; 
     
    3940 
    4041                this.add(relationsScroll); 
     42        } 
     43         
     44        public boolean Update(AgentModel am) 
     45        { 
     46                return false; 
    4147        } 
    4248 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/conditions/NewEventCondition.java

    r198 r211  
    7878                } 
    7979         
    80                 conditionVerified = (_positive == am.getMemory().getEpisodicMemory().ContainsRecentEvent(GetSearchKeys())); 
     80                conditionVerified = (_positive == am.getMemory().getEpisodicMemory().ContainsNewEvent(GetSearchKeys())); 
    8181                 
    8282                if(conditionVerified){ 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/emotionalState/EmotionalState.java

    r198 r211  
    141141                ActiveEmotion auxEmotion; 
    142142                EmotionDisposition disposition; 
     143                 
     144                if(potEm == null) return null; 
    143145 
    144146                potential = DeterminePotential(potEm); 
  • AgentMind/branches/FAtiMA2/src/FAtiMA/memory/episodicMemory/EpisodicMemory.java

    r198 r211  
    122122         
    123123        public boolean ContainsRecentEvent(ArrayList<SearchKey> searchKeys) 
     124        { 
     125                return _am.ContainsRecentEvent(searchKeys) || ContainsNewEvent(searchKeys); 
     126        } 
     127         
     128        public boolean ContainsNewEvent(ArrayList<SearchKey> searchKeys) 
    124129        {                
    125130                synchronized (this) { 
     
    176181        } 
    177182         
    178         public ArrayList<ActionDetail> SearchForRecentEvents(ArrayList<SearchKey> searchKeys) 
     183        public ArrayList<ActionDetail> SearchForRecentEvents(ArrayList<SearchKey> keys) 
     184        { 
     185                ArrayList<ActionDetail> aux = _am.SearchForRecentEvents(keys); 
     186                aux.addAll(_stm.GetDetailsByKeys(keys)); 
     187                 
     188                return aux; 
     189        } 
     190         
     191        public ArrayList<ActionDetail> SearchForNewEvents(ArrayList<SearchKey> searchKeys) 
    179192        {                
    180193                synchronized (this) { 
Note: See TracChangeset for help on using the changeset viewer.