nevrax.org : docs

00001 #include "nel/ai/agent/actor.h"
00002 #include "nel/ai/agent/agent_script.h"
00003 #include "nel/ai/agent/object_type.h"
00004 
00005 namespace NLAIAGENT
00006 {
00007 
00008 
00010         CActor::CActor() : IAgent(NULL)
00011         {
00012         }
00013 
00015         CActor::CActor(IAgent *father, bool activated) : IAgent( father )
00016         {
00017                 _IsActivated = activated;
00018         }
00019 
00021         CActor::CActor(const CActor &c) : IAgent( c )
00022         {
00023                 _IsActivated = c._IsActivated;
00024         }
00025 
00026         CActor::~CActor()
00027         {
00028 //              for (int i = 0; i < c._Transitions.size(); i++ )
00029                 //      _Transitions[i]->release();
00030         }
00031 
00033         bool CActor::isActivated()
00034         {
00035                 return _IsActivated;
00036         }
00037 
00039         void CActor::activate()
00040         {
00041                 if ( !_IsActivated )
00042                 {
00043                         onActivate();
00044                         _IsActivated = true;
00045                 }
00046         }
00047 
00049         void CActor::unActivate()
00050         {
00051                 if ( _IsActivated )
00052                 {
00053                         onUnActivate();
00054                         _IsActivated = false;
00055                 }
00056         }
00057 
00061         void CActor::forwardActivity(CActor *receiver, bool stay_active)
00062         {
00063                 receiver->activate();
00064 
00065                 if ( !stay_active )
00066                         unActivate();
00067         }
00068                 
00072         void CActor::forwardActivity(std::vector<CActor *> &actors, bool stay_active)
00073         {
00074                 std::vector<CActor *>::iterator it_act = actors.begin();
00075                 while ( it_act != actors.end() )
00076                 {
00077                         ( *it_act )->activate();
00078                         it_act++;
00079                 }
00080                 // TODO: Envoi de message "activate" 
00081                 if ( !stay_active )
00082                         unActivate();
00083         }
00084 
00086         void CActor::addTransition(NLAILOGIC::IBaseCond *cond, std::vector<CActor *> &outputs, bool stay_alive)
00087         {
00088 
00089         }
00090 
00091 //      void CActor::addTransition(CTransition *trans)
00092 //      {
00093 //              _Transitions.push_back( trans );
00094 //      }
00095 
00097         void CActor::onActivate()
00098         {
00099                 // Default behaviour: do nothing
00100         }
00102         void CActor::onUnActivate()
00103         {
00104                 // default behaviour: do nothing
00105         }
00106 
00107         const NLAIC::IBasicType *CActor::clone() const
00108         {               
00109                 CActor *m = new CActor(*this);
00110                 return m;
00111         }               
00112 
00113         const NLAIC::IBasicType *CActor::newInstance() const
00114         {       
00115                 NLAIC::IBasicInterface *m;
00116                 if ( getParent() != NULL ) 
00117                         m = new CActor((IAgent *)getParent());
00118                 else 
00119                         m = new CActor(NULL);
00120                 return m;
00121         }
00122         
00123         void CActor::getDebugString(char *t) const
00124         {
00125                 strcpy(t,"CActor ");
00126                 if ( _IsActivated )
00127                         strcat(t, "<active>");
00128                 else
00129                         strcat(t, "<idle>");
00130         }
00131 
00132         bool CActor::isEqual(const IBasicObjectIA &a) const
00133         {
00134                 return true;
00135         }
00136 
00137         void CActor::processMessages()
00138         {
00139                 IAgent::processMessages();
00140 /*              while(getMail()->getMessageCount())
00141                 {
00142                         const IMessageBase &msg = getMail()->getMessage();                              
00143                         run( msg );
00144                         getMail()->popMessage();
00145                 }*/
00146         }
00147 
00148         const IObjectIA::CProcessResult &CActor::run()
00149         {
00150                 if ( _IsActivated )
00151                 {
00152                         return IAgent::run();
00153                 }
00154                 else
00155                         return IObjectIA::ProcessRun;
00156                 /*
00157                 setState(processBuzzy,NULL); 
00158 
00159                 runChildren();          // Gestion des fils
00160                 getMail()->run();       // Execution de la boite aux lettres
00161 
00162                 processMessages();      // Traitement de ses propres messages
00163 
00164                 setState(processIdle,NULL);
00165                 return getState();  
00166                 */
00167         }
00168 
00169         /*IObjectIA *CActor::run(const IMessageBase &msg)
00170         {
00171                 return IAgent::run( msg );
00172         }*/
00173 
00174         const NLAIC::CIdentType &CActor::getType() const
00175         {               
00176                 return IdActor;
00177         }
00178 
00179         void CActor::save(NLMISC::IStream &os)
00180         {
00181                 IAgent::save(os);
00182                 os.serial( (bool &) _IsActivated );
00183                 
00184         }
00185 
00186         void CActor::load(NLMISC::IStream &is)
00187         {
00188                 IAgent::load(is);
00189         }
00190 
00191         tQueue CActor::isMember(const IVarName *className,const NLAIAGENT::IVarName *name,const IObjectIA &param) const
00192         {
00193                 tQueue result;
00194 
00195                 result = IAgent::isMember( className, name, param );
00196 
00197                 if ( result.size() )
00198                         return result;
00199 
00200 //              if(className != NULL) 
00201 //              {
00202                         if ( *name == CStringVarName("activate") )
00203                         {
00204                                 CObjectType *r_type = new CObjectType( new NLAIC::CIdentType( NLAIC::CIdentType::VoidType ) );
00205                                 result.push( NLAIAGENT::CIdMethod( fid_activate + IAgent::getMethodIndexSize(), 0.0,NULL, r_type ) );
00206                         }
00207 
00208                         if ( *name == CStringVarName("unActivate") )
00209                         {
00210                                 CObjectType *r_type = new CObjectType( new NLAIC::CIdentType( NLAIC::CIdentType::VoidType ) );
00211                                 result.push( NLAIAGENT::CIdMethod( fid_unActivate + IAgent::getMethodIndexSize(), 0.0,NULL, r_type ) );
00212                         }
00213 
00214                         if ( *name == CStringVarName("forwardActivity") )
00215                         {
00216                                 CObjectType *r_type = new CObjectType( new NLAIC::CIdentType( NLAIC::CIdentType::VoidType ) );
00217                                 result.push( NLAIAGENT::CIdMethod( fid_forwardActivity + IAgent::getMethodIndexSize(), 0.0,NULL, r_type ) );
00218                         }
00219 //              }
00220                 return result;
00221         }
00222 
00223         // Executes a method from its index id and with its parameters
00224         IObjectIA::CProcessResult CActor::runMethodeMember(sint32 id, IObjectIA *params)
00225         {
00226                 if ( id < IAgent::getMethodIndexSize() )
00227                         return IAgent::runMethodeMember(id, params);
00228 
00229                 IObjectIA::CProcessResult r;
00230 
00231                 char buf[1024];
00232                 getDebugString(buf);
00233 
00234                 id = id - IAgent::getMethodIndexSize();
00235                 
00236                 if ( id == fid_activate )
00237                 {
00238                         activate();
00239                         IObjectIA::CProcessResult r;
00240                         r.ResultState =  NLAIAGENT::processIdle;
00241                         r.Result = NULL;
00242                 }
00243 
00244                 if ( id == fid_unActivate )
00245                 {
00246                         unActivate();
00247                         IObjectIA::CProcessResult r;
00248                         r.ResultState =  NLAIAGENT::processIdle;
00249                         r.Result = NULL;
00250                 }
00251 
00252                 if ( id == fid_forwardActivity )
00253                 {
00254                         std::vector<CActor *> forwarded;
00255                         if ( ( (NLAIAGENT::IBaseGroupType *) params)->size() )
00256                         {
00257                                 IBaseGroupType *fw = (IBaseGroupType *) ( ((NLAIAGENT::IBaseGroupType *)params) )->getFront();
00258                                 ( ((NLAIAGENT::IBaseGroupType *)params))->popFront();
00259                                 while ( fw->size() )
00260                                 {
00261                                         forwarded.push_back( (CActor *) fw->getFront() );
00262                                         fw->popFront();
00263                                 }
00264                                 forwardActivity( forwarded, false );
00265                         }
00266                         IObjectIA::CProcessResult r;
00267                         r.ResultState =  NLAIAGENT::processIdle;
00268                         r.Result = NULL;
00269                 }
00270                 return r;
00271         }
00272 
00273         sint32 CActor::getMethodIndexSize() const
00274         {
00275                 return IAgent::getMethodIndexSize() + 2;
00276         }
00277 }
actor.cpp
