nevrax.org : docs

00001 #include "nel/ai/logic/goal.h"
00002 #include "nel/ai/logic/var.h"
00003 #include "nel/ai/agent/object_type.h"
00004 #include "nel/ai/logic/operator_script.h"
00005 #include "nel/ai/agent/msg_action.h"
00006 
00007 namespace NLAILOGIC
00008 {
00009 
00010 
00011         IGoal::IGoal() : IBaseBoolType()
00012         {
00013                 _Name = NULL;
00014                 _Sender = NULL;
00015                 _Receiver = NULL;
00016                 _Selected = false;
00017                 _Mode = achieveOnce;
00018         }
00019                 
00020         IGoal::IGoal(const NLAIAGENT::IVarName &name, TTypeOfGoal mode) : IBaseBoolType()
00021         {
00022                 _Name = (NLAIAGENT::IVarName *) name.clone();
00023                 _Sender = NULL;
00024                 _Receiver = NULL;
00025                 _Mode = mode;
00026                 _Selected = false;
00027         }
00028 
00029         IGoal::IGoal(const NLAIAGENT::IVarName &name, std::list<const NLAIAGENT::IObjectIA *> &args, TTypeOfGoal mode)
00030         {
00031                 _Name = (NLAIAGENT::IVarName *) name.clone();
00032                 while ( !args.empty() )
00033                 {
00034                         _Args.push_back( (NLAIAGENT::IObjectIA *) args.front()->clone() );
00035                         args.pop_front();
00036                 }
00037                 _Sender = NULL;
00038                 _Receiver = NULL;
00039                 _Mode = mode;
00040                 _Selected = false;
00041         }
00042 
00043         IGoal::IGoal(const IGoal &c) : IBaseBoolType()
00044         {
00045                 if ( c._Name )
00046                         _Name = (NLAIAGENT::IVarName *) c._Name->clone();
00047                 else
00048                         _Name = NULL;
00049                 _Sender =c._Sender;
00050                 _Receiver = c._Receiver;
00051                 _Mode = c._Mode;
00052 
00053                 for ( int i = 0; i < (int) c._Args.size(); i++ )
00054                         _Args.push_back( (NLAIAGENT::IObjectIA *) c._Args[i]->clone() );
00055 
00056                 _Selected = c._Selected;
00057         }
00058 
00059         IGoal::~IGoal()
00060         {
00061                 if ( _Name )
00062                         _Name->release();
00063 
00064                 int i;          
00065                 for ( i = 0; i < (int) _Args.size(); i++ )
00066                         _Args[i]->release();
00067                 
00068                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00069                 while ( it_s != _Successors.end() )
00070                 {                       
00071                         (*it_s ++)->release();                  
00072                 }
00073         }
00074 
00075 
00076         void IGoal::setSender(NLAIAGENT::IBasicAgent *s)
00077         {
00078                 _Sender = s;
00079         }
00080 
00081         void IGoal::setReceiver(NLAIAGENT::IBasicAgent *r)
00082         {
00083                 _Receiver = r;
00084         }
00085 
00086         NLAIAGENT::IBasicAgent *IGoal::getSender()
00087         {
00088                 return _Sender;
00089         }
00090 
00091         NLAIAGENT::IBasicAgent *IGoal::getReceiver()
00092         {
00093                 return _Receiver;
00094         }
00095 
00096         void IGoal::failure()
00097         {
00098                 if ( _Sender != NULL )
00099                 {
00100                         NLAIAGENT::IMessageBase *msg = new NLAIAGENT::CSuccessMsg((NLAIAGENT::IBasicAgent *)NULL);
00101                         msg->setPerformatif(NLAIAGENT::IMessageBase::PTell);
00102                         msg->setSender( this );
00103                         msg->setReceiver( _Sender);
00104                         _Sender->sendMessage(msg);
00105                 }
00106         }
00107 
00108         void IGoal::success()
00109         {
00110 
00111                 if ( _Sender != NULL )
00112                 {
00113                         NLAIAGENT::IMessageBase *msg = new NLAIAGENT::CSuccessMsg((NLAIAGENT::IBasicAgent *)NULL);
00114                         msg->setPerformatif(NLAIAGENT::IMessageBase::PTell);
00115                         msg->setSender( this );
00116                         msg->setReceiver( _Sender );
00117                         _Sender->sendMessage(msg);
00118                 }
00119         }
00120 
00121         void IGoal::operatorSuccess(NLAIAGENT::IBasicAgent *op)
00122         {
00123                 success();
00124 //              nlinfo("operatorSuccess: 0x%0x, %d, (0x%0x, %s)", this, _Successors.size(),op,(const char *)op->getType());
00125                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00126                 while ( it_s != _Successors.end() )
00127                 {                       
00128 /*
00129                         nlinfo("\t0x%0x",*it_s);
00130                         nlinfo("\t\t%s", (const char *)(*it_s)->getType());
00131 */
00132                         if ( (**it_s) == *op )
00133                         {
00134                                 (*it_s)->release();
00135                                 _Successors.erase( it_s );
00136                                 break;
00137                         }
00138                         it_s++;
00139                 }
00140 
00141                 switch ( _Mode )
00142                 {
00143                         case achieveOnce:
00144                                 ( (NLAIAGENT::CAgentScript *) _Receiver)->removeGoal( (NLAILOGIC::CGoal *) this );
00145                                 break;
00146 
00147                         case achieveForever:
00148                                 break;
00149                 }
00150 
00151         }
00152 
00153         void IGoal::operatorFailure(NLAIAGENT::IBasicAgent *op)
00154         {
00155                 failure();
00156                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00157                 while ( it_s != _Successors.end() )
00158                 {
00159                         if ( (**it_s) == *op )
00160                         {
00161                                 (*it_s)->release();
00162                                 _Successors.erase( it_s );
00163                                 break;
00164                         }
00165                         it_s++;
00166                 }
00167 
00168                 switch ( _Mode )
00169                 {
00170                         case achieveOnce:
00171                                 ( (NLAIAGENT::CAgentScript *) _Receiver )->removeGoal( (NLAILOGIC::CGoal *) this );
00172                                 break;
00173 
00174                         case achieveForever:
00175                                 break;
00176                 }
00177         }
00178 
00179         bool IGoal::isExclusive()
00180         {
00181                 if ( _Successors.empty() )
00182                         return false;
00183                 else
00184                         return ( (NLAIAGENT::COperatorScript *)_Successors.front())->isExclusive();
00185         }
00186 
00187         void IGoal::setPriority(float p)
00188         {
00189                 _Priority = p;
00190         }
00191 
00192         void IGoal::calcPriority()
00193         {
00194         }
00195 
00196         float IGoal::getPriority()
00197         {
00198                 return _Priority;
00199         }
00200 
00201 
00204 
00205         CGoal::CGoal() : IGoal()
00206         {
00207         }
00208                 
00209         CGoal::CGoal(const NLAIAGENT::IVarName &name, TTypeOfGoal mode) : IGoal(name, mode)
00210         {
00211         }
00212 
00213         CGoal::CGoal(const NLAIAGENT::IVarName &name, std::list<const NLAIAGENT::IObjectIA *> &args, TTypeOfGoal mode) : IGoal(name, args, mode)
00214         {
00215         }
00216 
00217         CGoal::CGoal(const CGoal &c) : IGoal( c )
00218         {
00219         }
00220 
00221         CGoal::~CGoal()
00222         {
00223         }
00224 
00225         void CGoal::operatorSuccess(NLAIAGENT::IBasicAgent *op)
00226         {
00227                 success();
00228 //              nlinfo("operatorSuccess: 0x%0x, %d, (0x%0x, %s)", this, _Successors.size(),op,(const char *)op->getType());
00229                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00230                 while ( it_s != _Successors.end() )
00231                 {                       
00232 /*
00233                         nlinfo("\t0x%0x",*it_s);
00234                         nlinfo("\t\t%s", (const char *)(*it_s)->getType());
00235 */
00236                         if ( (**it_s) == *op )
00237                         {
00238                                 (*it_s)->release();
00239                                 _Successors.erase( it_s );
00240                                 break;
00241                         }
00242                         it_s++;
00243                 }
00244 
00245                 switch ( _Mode )
00246                 {
00247                         case achieveOnce:
00248                                 {
00249                                         NLAIAGENT::CAgentScript *dest = (NLAIAGENT::CAgentScript *) _Receiver;
00250                                         dest->removeGoal( this );
00251                                 }
00252                                 break;
00253 
00254                         case achieveForever:
00255                                 break;
00256                 }
00257 
00258         }
00259 
00260         void CGoal::operatorFailure(NLAIAGENT::IBasicAgent *op)
00261         {
00262                 failure();
00263                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00264                 while ( it_s != _Successors.end() )
00265                 {
00266                         if ( (**it_s) == *op )
00267                         {
00268                                 (*it_s)->release();
00269                                 _Successors.erase( it_s );
00270                                 break;
00271                         }
00272                         it_s++;
00273                 }
00274 
00275                 switch ( _Mode )
00276                 {
00277                         case achieveOnce:
00278                                 ( (NLAIAGENT::CAgentScript *) _Receiver )->removeGoal( this );
00279                                 break;
00280 
00281                         case achieveForever:
00282                                 break;
00283                 }
00284         }
00285 
00286         const NLAIC::IBasicType *CGoal::clone() const
00287         {
00288                 NLAIC::IBasicInterface *m = new CGoal( *this );
00289                 return m;
00290         }
00291 
00292         const NLAIC::IBasicType *CGoal::newInstance() const
00293         {
00294                 return clone();
00295         }
00296 
00297 
00298         void CGoal::save(NLMISC::IStream &os)
00299         {                       
00300         }
00301 
00302         void CGoal::load(NLMISC::IStream &is)
00303         {
00304                 IObjectIA::load( is );
00305         }
00306 
00307         void CGoal::getDebugString(std::string &text) const
00308         {
00309                 text += "<CGoal> (";
00310                 if ( _Name ) 
00311                         text += _Name->getString();
00312                 std::string buf;
00313                 int i;
00314                 for ( i = 0; i < (int) _Args.size(); i++ )
00315                 {
00316                         _Args[i]->getDebugString(buf);
00317                         text += " ";
00318                         text += buf;
00319                 }
00320                 text += ") - ";
00321 
00322                 text += NLAIC::stringGetBuild(" PRI = %f", priority() );
00323                 text += " PRE = ";
00324 
00325                 for ( i = 0; i < (int) _Predecessors.size(); i++ )
00326                 {
00327                         _Predecessors[i]->getDebugString( buf );
00328                         text += buf;
00329                 }
00330                 text += " POST = ";
00331                 for ( i = 0; i < (int) _Successors.size(); i++ )
00332                 {
00333                         _Successors[i]->getDebugString( buf );
00334                         text += buf;
00335                 }
00336         }
00337 
00338         bool CGoal::isTrue() const
00339         {
00340                 return false;
00341         }
00342 
00343         float CGoal::truthValue() const
00344         {
00345                 return 1.0;
00346         }
00347 
00348         const NLAIAGENT::IObjectIA::CProcessResult &CGoal::run()
00349         {
00350                 return IObjectIA::ProcessRun;
00351         }
00352 
00353         bool CGoal::isEqual(const CGoal &a) const
00354         {
00355                 return false;
00356         }
00357 
00358         bool CGoal::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
00359         {
00360                 return false;
00361         }
00362 
00363         const std::vector<NLAIAGENT::IObjectIA *> &CGoal::getArgs()
00364         {
00365                 return _Args;
00366         }
00367 
00368         const NLAIC::CIdentType &CGoal::getType() const
00369         {
00370                 return IdGoal;
00371         }
00372 
00373         void CGoal::setArgs(std::list<NLAIAGENT::IObjectIA *> &args)
00374         {
00375                 std::list<NLAIAGENT::IObjectIA *>::iterator it_var = args.begin();
00376                 while ( it_var != args.end() )
00377                 {
00378                         _Args.push_back( (NLAIAGENT::IObjectIA *) (*it_var)->clone() );
00379                         it_var++;
00380                 }
00381         }
00382 
00383         NLAIAGENT::tQueue CGoal::isMember(const NLAIAGENT::IVarName *className,const NLAIAGENT::IVarName *funcName,const NLAIAGENT::IObjectIA &params) const
00384         {
00385 
00386 #ifdef NL_DEBUG 
00387         std::string nameP;
00388         std::string nameM;
00389         funcName->getDebugString(nameM);
00390         params.getDebugString(nameP);
00391         const char *dbg_class_name = (const char *) getType();
00392 #endif
00393                 static NLAIAGENT::CStringVarName constructor_name("Constructor");
00394                 static NLAIAGENT::CStringVarName mode_once_name("SetModeOnce");
00395                 static NLAIAGENT::CStringVarName mode_repeat_name("SetModeRepeat");
00396                 static NLAIAGENT::CStringVarName reply_to_name("ReplyTo");
00397 
00398                 NLAIAGENT::tQueue r;
00399                 if(className == NULL)
00400                 {
00401                         if( (*funcName) == constructor_name )
00402                         {                                       
00403                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CGoal::IdGoal ) );                                       
00404                                 r.push( NLAIAGENT::CIdMethod( 0 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00405                         }
00406 
00407                         if( (*funcName) == mode_once_name )
00408                         {                                       
00409                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CGoal::IdGoal ) );                                       
00410                                 r.push( NLAIAGENT::CIdMethod( 1 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00411                         }
00412 
00413                         if( (*funcName) == mode_repeat_name )
00414                         {                                       
00415                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CGoal::IdGoal ) );                                       
00416                                 r.push( NLAIAGENT::CIdMethod( 2 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00417                         }
00418 
00419                         if( (*funcName) == reply_to_name )
00420                         {                                       
00421                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CGoal::IdGoal ) );                                       
00422                                 r.push( NLAIAGENT::CIdMethod( 3 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00423                         }
00424                 }
00425 
00426                 if ( r.empty() )
00427                         return IBaseBoolType::isMember(className, funcName, params);
00428                 else
00429                         return r;
00430         }
00431 
00433 
00434         NLAIAGENT::IObjectIA::CProcessResult CGoal::runMethodeMember(sint32, sint32, NLAIAGENT::IObjectIA *)
00435         {
00436                 return IObjectIA::CProcessResult();
00437         }
00438 
00439         NLAIAGENT::IObjectIA::CProcessResult CGoal::runMethodeMember(sint32 index, NLAIAGENT::IObjectIA *p)
00440         {
00441                 NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)p;
00442 
00443                 switch(index - IObjetOp::getMethodIndexSize())
00444                 {
00445                         case 0:
00446                                 {                                       
00447 
00448                                         NLAIAGENT::CStringType *name = (NLAIAGENT::CStringType *) param->getFront();
00449                                         param->popFront();
00450 #ifdef NL_DEBUG
00451                                         const char *dbg_name = name->getStr().getString();
00452 #endif
00453                                         // If the constructor() function is explicitely called and the object has already been initialised
00454                                         if ( _Name )
00455                                                 _Name->release();
00456                                         _Args.clear();
00457 
00458                                         _Name = (NLAIAGENT::IVarName *) name->getStr().clone();
00459                                         std::list<const NLAIAGENT::IObjectIA *> args;
00460                                         while ( param->size() )
00461                                         {
00462                                                 _Args.push_back( (NLAIAGENT::IObjectIA *) param->getFront()->clone() );
00463                                                 param->popFront();
00464                                         }
00465                                         name->release();
00466                                         return IObjectIA::CProcessResult();             
00467                                 } 
00468                                 break;
00469                         
00470                         case 1:
00471                                 _Mode = achieveOnce;
00472                                 break;
00473 
00474                         case 2:
00475                                 _Mode = achieveForever;
00476                                 break;
00477 
00478                         case 3:
00479                                 {
00480                                         _Sender = ( NLAIAGENT::IBasicAgent *) ( (NLAIAGENT::CLocalAgentMail *) ( (NLAIAGENT::IBasicAgent *) param->getFront()) )->getHost();
00481                                         param->popFront();
00482                                 }
00483                                 break;
00484                 }
00485 
00486                 return IObjectIA::CProcessResult();
00487         }
00488 
00489         sint32 CGoal::getMethodIndexSize() const
00490         {
00491                 return IBaseBoolType::getMethodIndexSize() + 4;
00492         }
00494 
00495         void CGoal::addSuccessor(NLAIAGENT::IBasicAgent *s)
00496         {               
00497                 //nlinfo("addSuccessor: 0x%0x, %d, (0x%0x, %s)", this, _Successors.size(),s,(const char *)s->getType());
00498                 _Successors.push_back(s);
00499                 s->incRef();
00500         }
00501 
00502         void CGoal::addPredecessor(NLAIAGENT::IBasicAgent *p)
00503         {
00504                 _Predecessors.push_back(p);
00505                 p->incRef();
00506         }
00507 
00508         bool CGoal::operator==(const CGoal &g)
00509         {
00510                 if ( (*g._Name) == (*_Name) && _Args.size() == g._Args.size() )
00511                         return true;
00512 
00513                 return false;
00514         }
00515 
00516         void CGoal::cancel()
00517         {
00518                 std::vector<NLAIAGENT::IBasicAgent *>::iterator i, end = _Successors.end();
00519                 for ( i = _Successors.begin(); i != end; i++ )          
00520                 {
00521                         ( (NLAIAGENT::COperatorScript *)*i )->cancel();
00522                 }
00523         }
00524 
00525         float CGoal::priority() const
00526         {
00527                 if ( _Successors.empty() )
00528                         return 0.0;
00529 
00530                 float pri = 256;                
00531                 std::vector<NLAIAGENT::IBasicAgent *>::const_iterator i, end = _Successors.end();
00532                 for ( i = _Successors.begin(); i != end; i++ )
00533                 {
00534                         float suc_pri = ( (NLAIAGENT::COperatorScript *)*i )->priority();
00535                         if ( suc_pri < pri )
00536                         {
00537                                 pri = suc_pri;
00538                         }
00539                 }
00540                 return pri;
00541         }
00542 
00545 
00546         CInternalGoal::CInternalGoal() : IGoal()
00547         {
00548                 _Property = NULL;
00549         }
00550                 
00551         CInternalGoal::CInternalGoal(const NLAIAGENT::IVarName &name, TTypeOfGoal mode) : IGoal(name, mode)
00552         {
00553                 _Property = NULL;
00554         }
00555 
00556         CInternalGoal::CInternalGoal(const NLAIAGENT::IVarName &name, std::list<const NLAIAGENT::IObjectIA *> &args, TTypeOfGoal mode) : IGoal(name, args, mode)
00557         {
00558                 _Property = NULL;
00559         }
00560 
00561         CInternalGoal::CInternalGoal(const CInternalGoal &c) : IGoal( c )
00562         {
00563                 if ( c._Property != NULL )
00564                         setProperty( c._Property );
00565                 else
00566                         _Property = NULL;
00567         }
00568 
00569         CInternalGoal::~CInternalGoal()
00570         {
00571                 if ( _Property != NULL )
00572                         _Property->release();
00573         }
00574 
00575         void CInternalGoal::operatorSuccess(NLAIAGENT::IBasicAgent *op)
00576         {
00577 //              nlinfo("operatorSuccess: 0x%0x, %d, (0x%0x, %s)", this, _Successors.size(),op,(const char *)op->getType());
00578                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00579                 while ( it_s != _Successors.end() )
00580                 {                       
00581                         if ( (**it_s) == *op )
00582                         {
00583                                 (*it_s)->release();
00584                                 _Successors.erase( it_s );
00585                                 break;
00586                         }
00587                         it_s++;
00588                 }
00589 
00590                 switch ( _Mode )
00591                 {
00592                         case achieveOnce:
00593                                 ( (NLAIAGENT::CAgentScript *) _Receiver)->removeGoal( (NLAILOGIC::CGoal *) this );
00594                                 break;
00595 
00596                         case achieveForever:
00597                                 break;
00598                 }
00599 
00600         }
00601 
00602         void CInternalGoal::operatorFailure(NLAIAGENT::IBasicAgent *op)
00603         {
00604                 std::vector<NLAIAGENT::IBasicAgent *>::iterator it_s = _Successors.begin();
00605                 while ( it_s != _Successors.end() )
00606                 {
00607                         if ( (**it_s) == *op )
00608                         {
00609                                 (*it_s)->release();
00610                                 _Successors.erase( it_s );
00611                                 break;
00612                         }
00613                         it_s++;
00614                 }
00615 
00616                 switch ( _Mode )
00617                 {
00618                         case achieveOnce:
00619                                 ( (NLAIAGENT::CAgentScript *) _Receiver )->removeGoal( (NLAILOGIC::CGoal *) this );
00620                                 break;
00621 
00622                         case achieveForever:
00623                                 break;
00624                 }
00625         }
00626 
00627         const NLAIC::IBasicType *CInternalGoal::clone() const
00628         {
00629                 NLAIC::IBasicInterface *m = new CInternalGoal( *this );
00630                 return m;
00631         }
00632 
00633         const NLAIC::IBasicType *CInternalGoal::newInstance() const
00634         {
00635                 return clone();
00636         }
00637 
00638 
00639         void CInternalGoal::save(NLMISC::IStream &os)
00640         {                       
00641         }
00642 
00643         void CInternalGoal::load(NLMISC::IStream &is)
00644         {
00645                 IObjectIA::load( is );
00646         }
00647 
00648         void CInternalGoal::getDebugString(std::string &text) const
00649         {
00650                 text += "<CInternalGoal> (";
00651                 if ( _Name ) 
00652                         text += _Name->getString();
00653                 std::string buf;
00654                 int i;
00655                 for ( i = 0; i < (int) _Args.size(); i++ )
00656                 {
00657                         _Args[i]->getDebugString(buf);
00658                         text += " ";
00659                         text += buf;
00660                 }
00661                 text += ") - ";
00662 
00663                 text += NLAIC::stringGetBuild(" PRI = %f", priority() );
00664                 text += " PRE = ";
00665 
00666                 for ( i = 0; i < (int) _Predecessors.size(); i++ )
00667                 {
00668                         _Predecessors[i]->getDebugString( buf );
00669                         text += buf;
00670                 }
00671                 text += " POST = ";
00672                 for ( i = 0; i < (int) _Successors.size(); i++ )
00673                 {
00674                         _Successors[i]->getDebugString( buf );
00675                         text += buf;
00676                 }
00677         }
00678 
00679         bool CInternalGoal::isTrue() const
00680         {
00681                 return false;
00682         }
00683 
00684         float CInternalGoal::truthValue() const
00685         {
00686                 return 1.0;
00687         }
00688 
00689         const NLAIAGENT::IObjectIA::CProcessResult &CInternalGoal::run()
00690         {
00691                 return IObjectIA::ProcessRun;
00692         }
00693 
00694         bool CInternalGoal::isEqual(const CInternalGoal &a) const
00695         {
00696                 return false;
00697         }
00698 
00699         bool CInternalGoal::isEqual(const NLAIAGENT::IBasicObjectIA &a) const
00700         {
00701                 return false;
00702         }
00703 
00704         const std::vector<NLAIAGENT::IObjectIA *> &CInternalGoal::getArgs()
00705         {
00706                 return _Args;
00707         }
00708 
00709         const NLAIC::CIdentType &CInternalGoal::getType() const
00710         {
00711                 return IdInternalGoal;
00712         }
00713 
00714         void CInternalGoal::setArgs(std::list<NLAIAGENT::IObjectIA *> &args)
00715         {
00716                 std::list<NLAIAGENT::IObjectIA *>::iterator it_var = args.begin();
00717                 while ( it_var != args.end() )
00718                 {
00719                         _Args.push_back( (NLAIAGENT::IObjectIA *) (*it_var)->clone() );
00720                         it_var++;
00721                 }
00722         }
00723 
00724         NLAIAGENT::tQueue CInternalGoal::isMember(const NLAIAGENT::IVarName *className,const NLAIAGENT::IVarName *funcName,const NLAIAGENT::IObjectIA &params) const
00725         {
00726 
00727 #ifdef NL_DEBUG 
00728         std::string nameP;
00729         std::string nameM;
00730         funcName->getDebugString(nameM);
00731         params.getDebugString(nameP);
00732         const char *dbg_class_name = (const char *) getType();
00733 #endif
00734                 static NLAIAGENT::CStringVarName constructor_name("Constructor");
00735                 static NLAIAGENT::CStringVarName mode_once_name("SetModeOnce");
00736                 static NLAIAGENT::CStringVarName mode_repeat_name("SetModeRepeat");
00737                 NLAIAGENT::tQueue r;
00738                 if(className == NULL)
00739                 {
00740                         if( (*funcName) == constructor_name )
00741                         {                                       
00742                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CInternalGoal::IdInternalGoal ) );                                       
00743                                 r.push( NLAIAGENT::CIdMethod( 0 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00744                         }
00745 
00746                         if( (*funcName) == mode_once_name )
00747                         {                                       
00748                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CInternalGoal::IdInternalGoal ) );                                       
00749                                 r.push( NLAIAGENT::CIdMethod( 1 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00750                         }
00751 
00752                         if( (*funcName) == mode_repeat_name )
00753                         {                                       
00754                                 NLAIAGENT::CObjectType *c = new NLAIAGENT::CObjectType( new NLAIC::CIdentType( CInternalGoal::IdInternalGoal ) );                                       
00755                                 r.push( NLAIAGENT::CIdMethod( 2 + IObjetOp::getMethodIndexSize(), 0.0, NULL, c) );                                      
00756                         }
00757 
00758                 }
00759 
00760                 if ( r.empty() )
00761                         return IBaseBoolType::isMember(className, funcName, params);
00762                 else
00763                         return r;
00764         }
00765 
00767 
00768         NLAIAGENT::IObjectIA::CProcessResult CInternalGoal::runMethodeMember(sint32, sint32, NLAIAGENT::IObjectIA *)
00769         {
00770                 return IObjectIA::CProcessResult();
00771         }
00772 
00773         NLAIAGENT::IObjectIA::CProcessResult CInternalGoal::runMethodeMember(sint32 index, NLAIAGENT::IObjectIA *p)
00774         {
00775                 NLAIAGENT::IBaseGroupType *param = (NLAIAGENT::IBaseGroupType *)p;
00776 
00777                 switch(index - IObjetOp::getMethodIndexSize())
00778                 {
00779                         case 0:
00780                                 {                                       
00781 
00782                                         NLAIAGENT::CStringType *name = (NLAIAGENT::CStringType *) param->getFront();
00783                                         param->popFront();
00784 #ifdef NL_DEBUG
00785                                         const char *dbg_name = name->getStr().getString();
00786 #endif
00787                                         // If the constructor() function is explicitely called and the object has already been initialised
00788                                         if ( _Name )
00789                                                 _Name->release();
00790                                         _Args.clear();
00791 
00792                                         _Name = (NLAIAGENT::IVarName *) name->getStr().clone();
00793                                         std::list<const NLAIAGENT::IObjectIA *> args;
00794                                         while ( param->size() )
00795                                         {
00796                                                 _Args.push_back( (NLAIAGENT::IObjectIA *) param->getFront()->clone() );
00797                                                 param->popFront();
00798                                         }
00799                                         name->release();
00800                                         return IObjectIA::CProcessResult();             
00801                                 } 
00802                                 break;
00803                         
00804                         case 1:
00805                                 _Mode = achieveOnce;
00806                                 break;
00807 
00808                         case 2:
00809                                 _Mode = achieveForever;
00810                                 break;
00811                 }
00812 
00813                 return IObjectIA::CProcessResult();
00814         }
00815 
00816         sint32 CInternalGoal::getMethodIndexSize() const
00817         {
00818                 return IBaseBoolType::getMethodIndexSize() + 3;
00819         }
00821 
00822         void CInternalGoal::addSuccessor(NLAIAGENT::IBasicAgent *s)
00823         {               
00824                 //nlinfo("addSuccessor: 0x%0x, %d, (0x%0x, %s)", this, _Successors.size(),s,(const char *)s->getType());
00825                 _Successors.push_back(s);
00826                 s->incRef();
00827         }
00828 
00829         void CInternalGoal::addPredecessor(NLAIAGENT::IBasicAgent *p)
00830         {
00831                 _Predecessors.push_back(p);
00832                 p->incRef();
00833         }
00834 
00835         bool CInternalGoal::operator==(const CInternalGoal &g)
00836         {
00837                 if ( (*g._Name) == (*_Name) && _Args.size() == g._Args.size() )
00838                         return true;
00839 
00840                 return false;
00841         }
00842 
00843         void CInternalGoal::setSender(NLAIAGENT::IBasicAgent *s)
00844         {
00845                 _Sender = s;
00846         }
00847 
00848         void CInternalGoal::setReceiver(NLAIAGENT::IBasicAgent *r)
00849         {
00850                 _Receiver = r;
00851         }
00852 
00853         NLAIAGENT::IBasicAgent *CInternalGoal::getSender()
00854         {
00855                 return _Sender;
00856         }
00857 
00858         NLAIAGENT::IBasicAgent *CInternalGoal::getReceiver()
00859         {
00860                 return _Receiver;
00861         }
00862 
00863         void CInternalGoal::cancel()
00864         {
00865                 std::vector<NLAIAGENT::IBasicAgent *>::iterator i, end = _Successors.end();
00866                 for ( i = _Successors.begin(); i != end; i++ )          
00867                 {
00868                         ( (NLAIAGENT::COperatorScript *)*i )->cancel();
00869                 }
00870         }
00871 
00872         float CInternalGoal::priority() const
00873         {
00874                 if ( _Successors.empty() )
00875                         return 0.0;
00876 
00877                 float pri = 256;                
00878                 std::vector<NLAIAGENT::IBasicAgent *>::const_iterator i, end = _Successors.end();
00879                 for ( i = _Successors.begin(); i != end; i++ )
00880                 {
00881                         float suc_pri = ( (NLAIAGENT::COperatorScript *)*i )->priority();
00882                         if ( suc_pri < pri )
00883                         {
00884                                 pri = suc_pri;
00885                         }
00886                 }
00887                 return pri;
00888         }
00889 
00890 
00891         void CInternalGoal::setProperty(NLAIAGENT::IObjectIA *property)
00892         {
00893                 if ( _Property != NULL )
00894                 {
00895                         _Property->release();   
00896                 }
00897                 _Property = property;
00898         }
00899 }
00900 
00901 
00902 
00903 
00904 
00905 
00906 
00907
goal.cpp
