nevrax.org : docs

00001 
+00006 /* Copyright, 2000 Nevrax Ltd.
+00007  *
+00008  * This file is part of NEVRAX NEL.
+00009  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00010  * it under the terms of the GNU General Public License as published by
+00011  * the Free Software Foundation; either version 2, or (at your option)
+00012  * any later version.
+00013 
+00014  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00017  * General Public License for more details.
+00018 
+00019  * You should have received a copy of the GNU General Public License
+00020  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00021  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00022  * MA 02111-1307, USA.
+00023  */
+00024 #include <time.h>
+00025 #include "nel/ai/script/compilateur.h"
+00026 #include "nel/ai/script/interpret_object_message.h"
+00027 #include "nel/ai/script/interpret_object_manager.h"
+00028 #include "nel/ai/script/interpret_actor.h"
+00029 #include "nel/ai/script/test_method.h"
+00030 #include "nel/ai/script/type_def.h"
+00031 #include "nel/ai/script/object_unknown.h"
+00032 #include "nel/ai/agent/agent_digital.h"
+00033 
+00034 
+00035 namespace NLAISCRIPT
+00036 {
+00037         CLibTest test;
+00038         const NLAIC::CIdentType CLibTest::IdLibTest = NLAIC::CIdentType("External",
+00039                                                                                                                                         NLAIC::CSelfClassFactory(test),
+00040                                                                                                                                         NLAIC::CTypeOfObject(NLAIC::CTypeOfObject::tObject),NLAIC::CTypeOfOperator(0));
+00041 
+00042         //const char *IsNULL = ;
+00043         CLibTest::CMethodCall **CLibTest::StaticMethod = NULL;
+00044         /*{
+00045                 
+00046 
+00047                 CLibTest::CMethodCall(  _CONSTRUCTOR_,
+00048                                                                 CLibTest::TConst, NULL,
+00049                                                                 CLibTest::CheckCount,
+00050                                                                 0,
+00051                                                                 new CObjectUnknown(new NLAISCRIPT::COperandVoid)),
+00052 
+00053                 CLibTest::CMethodCall(  "IsNotNull", 
+00054                                                                 CLibTest::TIsNULL, NULL,
+00055                                                                 CLibTest::CheckCount,
+00056                                                                 1,
+00057                                                                 new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType)))),
+00058 
+00059                 CLibTest::CMethodCall(  "Rand", 
+00060                                                                 CLibTest::TRand1, 
+00061                                                                 new NLAISCRIPT::CParam(1,new NLAISCRIPT::COperandSimpleListOr(2,
+00062                                                                                                                         new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00063                                                                                                                         new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType))),
+00064                                                                 CLibTest::CheckAll,
+00065                                                                 1,
+00066                                                                 new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType)))),
+00067 
+00068                 CLibTest::CMethodCall(  "Rand", 
+00069                                                                 CLibTest::TRand2, 
+00070                                                                 new NLAISCRIPT::CParam(2,new NLAISCRIPT::COperandSimpleListOr(2,
+00071                                                                                                                         new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00072                                                                                                                         new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType)),
+00073                                                                                                                         new NLAISCRIPT::COperandSimpleListOr(2,
+00074                                                                                                                         new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00075                                                                                                                         new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType))),
+00076                                                                 CLibTest::CheckAll,
+00077                                                                 2,
+00078                                                                 new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType))))
+00079         };*/
+00080         void CLibTest::initClass()
+00081         {
+00082                 CLibTest::StaticMethod = new CLibTest::CMethodCall *[CLibTest::TLastM];
+00083 
+00084                 CLibTest::StaticMethod[CLibTest::TConst] = new CLibTest::CMethodCall(   _CONSTRUCTOR_,
+00085                                                                                         CLibTest::TConst, NULL,
+00086                                                                                         CLibTest::CheckCount,
+00087                                                                                         0,
+00088                                                                                         new CObjectUnknown(new NLAISCRIPT::COperandVoid));
+00089 
+00090                 CLibTest::StaticMethod[CLibTest::TIsNULL] = new CLibTest::CMethodCall(  
+00091                                                                                                 "IsNotNull", 
+00092                                                                                                 CLibTest::TIsNULL, NULL,
+00093                                                                                                 CLibTest::CheckCount,
+00094                                                                                                 1,
+00095                                                                                                 new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType))));
+00096 
+00097                 CLibTest::StaticMethod[CLibTest::TRand1] = new CLibTest::CMethodCall(
+00098                                                                                         "Rand", 
+00099                                                                                         CLibTest::TRand1, 
+00100                                                                                         new NLAISCRIPT::CParam(1,new NLAISCRIPT::COperandSimpleListOr(2,
+00101                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00102                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType))),
+00103                                                                                         CLibTest::CheckAll,
+00104                                                                                         1,
+00105                                                                                         new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType))));
+00106 
+00107                 CLibTest::StaticMethod[CLibTest::TRand2] = new CLibTest::CMethodCall(
+00108                                                                                         "Rand", 
+00109                                                                                         CLibTest::TRand2, 
+00110                                                                                         new NLAISCRIPT::CParam(2,new NLAISCRIPT::COperandSimpleListOr(2,
+00111                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00112                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType)),
+00113                                                                                                                                                 new NLAISCRIPT::COperandSimpleListOr(2,
+00114                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00115                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType))),
+00116                                                                                         CLibTest::CheckAll,
+00117                                                                                         2,
+00118                                                                                         new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType))));
+00119 
+00120                 CLibTest::StaticMethod[CLibTest::TDiscretRand] = new CLibTest::CMethodCall(
+00121                                                                                         "DRand", 
+00122                                                                                         CLibTest::TDiscretRand, 
+00123                                                                                         new NLAISCRIPT::CParam(2,new NLAISCRIPT::COperandSimpleListOr(2,
+00124                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00125                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType)),
+00126                                                                                                                                                 new NLAISCRIPT::COperandSimpleListOr(2,
+00127                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType),
+00128                                                                                                                                                 new NLAIC::CIdentType(NLAIAGENT::DigitalType::IdDigitalType))),
+00129                                                                                         CLibTest::CheckAll,
+00130                                                                                         2,
+00131                                                                                         new CObjectUnknown(new COperandSimple(new NLAIC::CIdentType(NLAIAGENT::DDigitalType::IdDDigitalType))));
+00132 
+00133         }
+00134 
+00135         void CLibTest::releaseClass()
+00136         {
+00137                 int i;
+00138                 for(i = 0; i < CLibTest::TLastM; i++)
+00139                 {
+00140                         delete CLibTest::StaticMethod[i];
+00141                 }
+00142                 delete CLibTest::StaticMethod;
+00143         }
+00144 
+00145 
+00146         CLibTest::CLibTest()
+00147         {       
+00148 
+00149                 //srand(clock());
+00150 
+00151         }
+00152         sint32 CLibTest::isClassInheritedFrom(const NLAIAGENT::IVarName &className) const
+00153         {
+00154                 NLAIAGENT::CStringVarName check((const char *)IdLibTest);
+00155 
+00156                 if(className == check)
+00157                 {
+00158                         return 0;
+00159                 }
+00160                 else return -1;         
+00161         }
+00162 
+00163         NLAIAGENT::tQueue CLibTest::isMember(const NLAIAGENT::IVarName *className,const NLAIAGENT::IVarName *methodName,const NLAIAGENT::IObjectIA &param) const
+00164         {
+00165                 NLAIAGENT::tQueue r;
+00166                 NLAIAGENT::CStringVarName check((const char *)IdLibTest);
+00167 
+00168                 if(className == NULL || *className == check)
+00169                 {
+00170                         sint i;
+00171                         CLibTest::TMethodNumDef index;
+00172                         for(i = 0; i < CLibTest::TLastM; i ++)
+00173                         {
+00174                                 if(CLibTest::StaticMethod[i]->MethodName == *methodName)
+00175                                 {
+00176                                         index = (CLibTest::TMethodNumDef)CLibTest::StaticMethod[i]->Index;
+00177                                         switch(CLibTest::StaticMethod[i]->CheckArgType)
+00178                                         {
+00179                                                 case CLibTest::CheckAll:
+00180                                                 {
+00181                                                         double d = ((NLAISCRIPT::CParam &)*CLibTest::StaticMethod[i]->ArgType).eval((NLAISCRIPT::CParam &)param);
+00182                                                         if(d >= 0.0)
+00183                                                         {                                                                                                                               
+00184                                                                 CLibTest::StaticMethod[i]->ReturnValue->incRef();
+00185                                                                 r.push(NLAIAGENT::CIdMethod((CLibTest::getMethodIndexSize() + CLibTest::StaticMethod[i]->Index),
+00186                                                                                                                         0.0,
+00187                                                                                                                         NULL,
+00188                                                                                                                         CLibTest::StaticMethod[i]->ReturnValue));
+00189                                                                 return r;
+00190                                                         }
+00191                                                 }
+00192                                                 break;
+00193                                                 case CLibTest::CheckCount:
+00194                                                 {
+00195                                                         if(((NLAISCRIPT::CParam &)param).size() == CLibTest::StaticMethod[i]->ArgCount)
+00196                                                         {                                                                                                                               
+00197                                                                 CLibTest::StaticMethod[i]->ReturnValue->incRef();
+00198                                                                 r.push(NLAIAGENT::CIdMethod((CLibTest::getMethodIndexSize() + CLibTest::StaticMethod[i]->Index),
+00199                                                                                                                         0.0,
+00200                                                                                                                         NULL,
+00201                                                                                                                         CLibTest::StaticMethod[i]->ReturnValue ));
+00202                                                                 return r;
+00203                                                         }
+00204                                                 }
+00205                                                 break;
+00206 
+00207                                         case CLibTest::DoNotCheck:
+00208                                                 {                                                                                                               
+00209                                                         CLibTest::StaticMethod[i]->ReturnValue->incRef();
+00210                                                         r.push(NLAIAGENT::CIdMethod((CLibTest::getMethodIndexSize() + CLibTest::StaticMethod[i]->Index),
+00211                                                                                                                 0.0,
+00212                                                                                                                 NULL,
+00213                                                                                                                 CLibTest::StaticMethod[i]->ReturnValue));
+00214                                                         return r;                                               
+00215                                                 }
+00216                                                 break;                                  
+00217                                         }
+00218                                 }
+00219 
+00220                         }                       
+00221                 }
+00222                 return r;
+00223         }               
+00224 
+00225         NLAIAGENT::IObjectIA::CProcessResult CLibTest::runMethodeMember(sint32 heritance, sint32 index, NLAIAGENT::IObjectIA *)
+00226         {
+00227                 return NLAIAGENT::IObjectIA::ProcessRun;
+00228         }
+00229 
+00230         NLAIAGENT::IObjectIA::CProcessResult CLibTest::runMethodeMember(sint32 index,NLAIAGENT::IObjectIA *p)
+00231         {               
+00232                 NLAIAGENT::IObjectIA::CProcessResult r;
+00233 
+00234                 switch(index)
+00235                 {
+00236                 case CLibTest::TIsNULL:
+00237                         {
+00238                                 NLAIAGENT::IObjectIA *param = (NLAIAGENT::IObjectIA *)((NLAIAGENT::IBaseGroupType *)p)->get();
+00239                                 if( ((const NLAIC::CTypeOfObject &)param->getType()) & NLAIC::CTypeOfObject::tNombre)
+00240                                 {                       
+00241                                         param->incRef();
+00242                                         r.Result = param;
+00243                                         return r;
+00244                                 }
+00245                                 else
+00246                                 {
+00247                                         r.Result = new NLAIAGENT::DigitalType(1.0);
+00248                                         return r;
+00249                                 }
+00250                         }
+00251                         break;
+00252                 case CLibTest::TRand1:
+00253                         {
+00254                                 NLAIAGENT::DDigitalType *param = (NLAIAGENT::DDigitalType *)((NLAIAGENT::IBaseGroupType *)p)->get();
+00255                                 r.Result = new NLAIAGENT::DDigitalType(rand(0.0,param->getNumber()));
+00256                                 return r;
+00257                         }                       
+00258 
+00259                 case CLibTest::TRand2:
+00260                         {
+00261                                 NLAIAGENT::CIteratorContener iter = ((NLAIAGENT::IBaseGroupType *)p)->getIterator();
+00262                                 NLAIAGENT::DDigitalType *p1 = (NLAIAGENT::DDigitalType *)(iter ++);
+00263                                 NLAIAGENT::DDigitalType *p2 = (NLAIAGENT::DDigitalType *)(iter ++);
+00264                                 r.Result = new NLAIAGENT::DDigitalType(rand(p1->getNumber(),p2->getNumber()));
+00265                                 return r;
+00266                         }
+00267 
+00268                 case CLibTest::TDiscretRand:
+00269                         {
+00270                                 NLAIAGENT::CIteratorContener iter = ((NLAIAGENT::IBaseGroupType *)p)->getIterator();
+00271                                 NLAIAGENT::DDigitalType *p1 = (NLAIAGENT::DDigitalType *)(iter ++);
+00272                                 NLAIAGENT::DDigitalType *p2 = (NLAIAGENT::DDigitalType *)(iter ++);
+00273                                 r.Result = new NLAIAGENT::DDigitalType((double)dRand((sint)p1->getNumber(), (sint)p2->getNumber()));
+00274                                 return r;
+00275                         }
+00276 /*
+00277                 case TIdle:
+00278                         {
+00279                                 r.ResultState =  NLAIAGENT::processIdle;
+00280                                 r.Result = new NLAIAGENT::DigitalType( CEntityState::Idle );
+00281                         }
+00282                         break;
+00283 
+00284                 case TWalk:
+00285                         {
+00286                                 r.ResultState =  NLAIAGENT::processIdle;
+00287                                 r.Result = new NLAIAGENT::DigitalType( CEntityState::Idle );
+00288                         }
+00289                         break;
+00290 
+00291                 case TYes:
+00292                         {
+00293                                 r.ResultState =  NLAIAGENT::processIdle;
+00294                                 r.Result = new NLAIAGENT::DigitalType( CEntityState::Idle );
+00295                         }
+00296                         break;
+00297 
+00298                 case TNo:
+00299                         {
+00300                                 r.ResultState =  NLAIAGENT::processIdle;
+00301                                 r.Result = new NLAIAGENT::DigitalType( CEntityState::Idle );
+00302                         }
+00303                         break;
+00304 
+00305                 case TWave:
+00306                         {
+00307                                 r.ResultState =  NLAIAGENT::processIdle;
+00308                                 r.Result = new NLAIAGENT::DigitalType( CEntityState::Idle );
+00309                         }
+00310                         break;
+00311 
+00312                 case TBow:
+00313                         {
+00314                                 r.ResultState =  NLAIAGENT::processIdle;
+00315                                 r.Result = new NLAIAGENT::DigitalType( CEntityState::Idle );
+00316                         }
+00317                         break;
+00318                         */
+00319                 }
+00320                 return r;
+00321         }
+00322 
+00323         double CLibTest::rand(double d1, double d2) const
+00324         {
+00325                 double r = ((double)::rand() - (((double)RAND_MAX)/2));
+00326 
+00327                 r /= ((double)RAND_MAX);
+00328 
+00329                 return d1 + r*(d2 - d1);
+00330 
+00331         }
+00332 
+00333         sint CLibTest::dRand(sint d1, sint d2) const
+00334         {
+00335                 //srand((sint16)clock() );
+00336                 sint ra = ::rand();
+00337                 sint d = (d2 - d1);
+00338                 if(d < 0) d = -d;
+00339                 if(!d) d = 1;
+00340                 sint r = d1 + (ra%d);
+00341 
+00342                 return r;
+00343 
+00344         }
+00345 
+00346 }
+00347 
+
test_method.cpp
