# Home    # nevrax.com   
Nevrax
Nevrax.org
#News
#Mailing-list
#Documentation
#CVS
#Bugs
#License
Docs
 
Documentation  
Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   Compound Members   File Members   Related Pages   Search  

actor.cpp

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