nevrax.org : docs

00001 
00007 /* Copyright, 2000 Nevrax Ltd.
00008  *
00009  * This file is part of NEVRAX NEL.
00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
00011  * it under the terms of the GNU General Public License as published by
00012  * the Free Software Foundation; either version 2, or (at your option)
00013  * any later version.
00014 
00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00018  * General Public License for more details.
00019 
00020  * You should have received a copy of the GNU General Public License
00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00023  * MA 02111-1307, USA.
00024  */
00025 
00026 
00027 #include "nel/ai/agent/agent_digital.h"
00028 #include "nel/ai/script/interpret_methodes.h"
00029 #include "nel/ai/script/type_def.h"
00030 #include "nel/ai/agent/object_type.h"
00031 #include "nel/ai/agent/agent_method_def.h"
00032 #include "nel/ai/agent/agent_3dvector.h"
00033 
00034 // Add some code in the namespace "NLAIAGENT".
00035 namespace NLAIAGENT
00036 {
00037 
00038         /****************************************************
00039          * 
00040          */
00041         sint32 IVector::getMethodIndexSize() const
00042         {
00043                 return getMethodIndexSize() + 10;
00044         }
00045 
00046         /****************************************************
00047          * 
00048          */
00049         tQueue IVector::isMember(const IVarName *baseClass,const IVarName *methodName,const IObjectIA &p) const
00050         {               
00051                 //Type IVarName voir agent_string.h.
00052                 static const CStringVarName methodX("x");
00053                 static const CStringVarName methodY("y");
00054                 static const CStringVarName methodZ("z");
00055                 static const CStringVarName methodSquareLength("SquareLength");
00056                 static const CStringVarName methodLength("Length");
00057                 static const CStringVarName methodUnit("Unit");
00058                 static const CStringVarName selfName((const char *)getType());
00059                 static const CStringVarName constructor(_CONSTRUCTOR_);
00060 
00061                 //NLAISCRIPT::CParam est le type reel de p voir nel/ai/script/interpret_methodes.h pour la declaration de la class.
00062                 const NLAISCRIPT::CParam &param = (const NLAISCRIPT::CParam &)p;
00063                         
00064                 if(baseClass == NULL || (*baseClass) == selfName)
00065                 {
00066                         if((*methodName) == methodX)
00067                         {
00068                                 if(!param.size())
00069                                 {
00070                                         tQueue a;
00071                                         //Type du retour de la method x(), c'est un Float dont de type DDigitalType c'est à dire DDigitalType::IDDigitalType;
00072                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00073                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));
00074                                         t->incRef();
00075                                         //CIdMethod est dans basicai.h elle va être documenter.
00076                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 1,0.0,NULL,t));
00077                                         return a;
00078                                 }
00079                                 else
00080                                 {
00081                                         NLAISCRIPT::CParam xParam;
00082                                         xParam.push(NLAISCRIPT::COperandSimple(new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
00083                                         if(param == xParam)
00084                                         {               
00085                                                 tQueue a;
00086                                                 //Type du retour de la method x(), c'est un void dont de type VoidType c'est à dire NLAIC::CIdentType::VoidType;
00087                                                 //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00088                                                 //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
00089                                                 NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));
00090                                                 t->incRef();
00091                                                 //CIdMethod est dans basicai.h elle va être documenter.
00092                                                 a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 2,0.0,NULL,t));
00093                                                 return a;
00094                                         }
00095                                 }
00096                         }
00097                         else if((*methodName) == methodY)
00098                         {
00099                                 if(!param.size())
00100                                 {
00101                                         tQueue a;
00102                                         //Type du retour de la method y(), c'est un Float dont de type DDigitalType c'est à dire DDigitalType::IdDDigitalType;
00103                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00104                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));
00105                                         t->incRef();
00106                                         //CIdMethod est dans basicai.h elle va être documenter.
00107                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 3,0.0,NULL,t));
00108                                         return a;
00109                                 }
00110                                 else
00111                                 {
00112                                         NLAISCRIPT::CParam xParam;
00113                                         xParam.push(NLAISCRIPT::COperandSimple(new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
00114                                         if(param == xParam)
00115                                         {               
00116                                                 tQueue a;
00117                                                 //Type du retour de la method y(), c'est un void dont de type VoidType c'est à dire CIdentType::VoidType;
00118                                                 //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00119                                                 //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
00120                                                 NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                             
00121                                                 //CIdMethod est dans basicai.h elle va être documenter.
00122                                                 a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 4,0.0,NULL,t));
00123                                                 return a;
00124                                         }
00125                                 }
00126                         }
00127                         if((*methodName) == methodZ)
00128                         {
00129                                 if(!param.size())
00130                                 {
00131                                         tQueue a;
00132                                         //Type du retour de la method x(), c'est un Float dont de type DDigitalType c'est à dire DDigitalType::IdDDigitalType;
00133                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00134                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));                                    
00135                                         //CIdMethod est dans basicai.h elle va être documenter.
00136                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 5,0.0,NULL,t));
00137                                         return a;
00138                                 }
00139                                 else
00140                                 {
00141                                         NLAISCRIPT::CParam xParam;
00142                                         xParam.push(NLAISCRIPT::COperandSimple(new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
00143                                         if(param == xParam)
00144                                         {               
00145                                                 tQueue a;
00146                                                 //Type du retour de la method x(), c'est un void dont de type VoidType c'est à dire NLAIC::CIdentType::VoidType;
00147                                                 //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00148                                                 //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
00149                                                 NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                             
00150                                                 //CIdMethod est dans basicai.h elle va être documenter.
00151                                                 a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 6,0.0,NULL,t));
00152                                                 return a;
00153                                         }
00154                                 }
00155                         }
00156                         else if((*methodName) == methodSquareLength)
00157                         {
00158                                 if(!param.size())
00159                                 {
00160                                         tQueue a;
00161                                         //Return a void type (no value return)
00162                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));                                    
00163                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 7,0.0,NULL,t));
00164                                         return a;
00165                                 }
00166                         }
00167                         else if((*methodName) == methodLength)
00168                         {
00169                                 if(!param.size())
00170                                 {
00171                                         tQueue a;
00172                                         //Return a digital type
00173                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(DDigitalType::IdDDigitalType));                                    
00174                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 8,0.0,NULL,t));
00175                                         return a;
00176                                 }
00177                         }
00178                         else if((*methodName) == methodUnit)
00179                         {
00180                                 if(!param.size())
00181                                 {
00182                                         tQueue a;
00183                                         //Return a void type
00184                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                     
00185                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 9,0.0,NULL,t));
00186                                         return a;
00187                                 }
00188                         }
00189                         else if((*methodName) == constructor)
00190                         {
00191                                 NLAISCRIPT::CParam constructParam;
00192                                 constructParam.push(NLAISCRIPT::COperandSimpleListOr(2,new NLAIC::CIdentType(DDigitalType::IdDDigitalType),new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
00193                                 constructParam.push(NLAISCRIPT::COperandSimpleListOr(2,new NLAIC::CIdentType(DDigitalType::IdDDigitalType),new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
00194                                 constructParam.push(NLAISCRIPT::COperandSimpleListOr(2,new NLAIC::CIdentType(DDigitalType::IdDDigitalType),new NLAIC::CIdentType(DDigitalType::IdDDigitalType)));
00195                                 if(constructParam.eval(param) >= 0.0 )
00196                                 {               
00197                                         tQueue a;
00198                                         //Type du retour du constructeur , c'est un void dont de type VoidType c'est à dire CIdentType::VoidType;
00199                                         //CObjectType est un IObjectIA qui permet d'encapsuler un NLAIC::CIdentType c'est à dire un type.
00200                                         //la variable NLAIC::CIdentType::VoidType est un static dans la class NLAIC::CIdentType.
00201                                         NLAIAGENT::CObjectType *t = new NLAIAGENT::CObjectType(new NLAIC::CIdentType(NLAIC::CIdentType::VoidType));                                     
00202                                         //CIdMethod est dans basicai.h elle va être documentee.
00203                                         a.push(CIdMethod(IObjetOp::getMethodIndexSize() + 0,0.0,NULL,t));
00204                                         return a;
00205                                 }
00206                         }
00207                 }
00208                 return IObjetOp::isMember(baseClass,methodName,p);
00209         }
00210 
00211         /****************************************************
00212          * 
00213          */
00214         sint32 IVector::isClassInheritedFrom(const IVarName &baseClass) const
00215         {
00216 
00218                 //Cette class n'a aucun heritage.
00219                 const CStringVarName selfName((const char *)getType());
00220                 //ça c'est si jamais quelqu'un ecrit un truc du type Vector.x() où Vector est le non de cette class dans le script.
00221                 if((baseClass) == selfName) return 0;           
00222                 else return -1;
00224 /*
00225                 //Cette class n'a aucun heritage.
00226                 const CStringVarName selfName((const char *)getType());
00227                 //ça c'est si jamais quelqu'un ecrit un truc du type Vector.x() où Vector est le non de cette class dans le script.
00228                 if((baseClass) == selfName) return 0 + IObjetOp::getInheritedSize();
00229                 else return IObjetOp::isClassInheritedFrom(baseClass);
00230 */
00231         }
00232 
00233         /****************************************************
00234          * 
00235          */
00236         IObjectIA::CProcessResult IVector::runMethodeMember(sint32 baseClassTag, sint32 methodTag, IObjectIA *p)
00237         {
00239                 if(baseClassTag == 0)
00240                 {
00241                         return runMethodeMember(methodTag,p);
00242                 }
00244 /*              if(baseClassTag == (0+IObjetOp::getInheritedSize()) )
00245                 {
00246                         return runMethodeMember(methodTag,p);
00247                 }
00248 */
00249                 return IObjectIA::runMethodeMember(baseClassTag,methodTag,p);
00250 
00251         }
00252 
00253         /****************************************************
00254          * 
00255          */
00256         IObjectIA::CProcessResult IVector::runMethodeMember(sint32 methodTag,IObjectIA *p)
00257         {
00258                 IBaseGroupType &param = (IBaseGroupType &)*p;
00259 
00260                 switch(methodTag - IObjetOp::getMethodIndexSize())
00261                 {
00262                 case 0:
00263                         {
00264                                 CIteratorContener i = param.getIterator();
00265                                 const INombreDefine *o = (const INombreDefine *)i++;
00266                                 x(o->getNumber());
00267                                 o = (const INombreDefine *)i++;                         
00268                                 y(o->getNumber());
00269                                 o = (const INombreDefine *)i++;                         
00270                                 z(o->getNumber());
00271                                 IObjectIA::CProcessResult a;
00272                                 a.ResultState = processIdle;
00273                                 a.Result = NULL;
00274                                 return a;
00275                         }
00276 
00277                 case 1:
00278                         {                               
00279                                 DDigitalType *r = new DDigitalType(x());
00280                                 r->incRef();
00281                                 IObjectIA::CProcessResult a;
00282                                 a.ResultState = processIdle;
00283                                 a.Result = r;
00284                                 return a;
00285                         }                                               
00286 
00287                 case 2:
00288                         {
00289                                 
00290                                 x(((const INombreDefine *)param.get())->getNumber());
00291                                 IObjectIA::CProcessResult a;
00292                                 a.ResultState = processIdle;
00293                                 a.Result = NULL;
00294                                 return a;
00295                         }                       
00296 
00297                 case 3:
00298                         {                               
00299                                 DDigitalType *r = new DDigitalType(y());
00300                                 r->incRef();
00301                                 IObjectIA::CProcessResult a;
00302                                 a.ResultState = processIdle;
00303                                 a.Result = r;
00304                                 return a;
00305                         }                                               
00306 
00307                 case 4:
00308                         {
00309                                 y(((const INombreDefine *)param.get())->getNumber());
00310                                 IObjectIA::CProcessResult a;
00311                                 a.ResultState = processIdle;
00312                                 a.Result = NULL;
00313                                 return a;
00314                         }                       
00315 
00316                 case 5:
00317                         {                               
00318                                 DDigitalType *r = new DDigitalType(z());
00319                                 r->incRef();
00320                                 IObjectIA::CProcessResult a;
00321                                 a.ResultState = processIdle;
00322                                 a.Result = r;
00323                                 return a;
00324                         }                                               
00325 
00326                 case 6:
00327                         {
00328                                 z(((const INombreDefine *)param.get())->getNumber());
00329                                 IObjectIA::CProcessResult a;
00330                                 a.ResultState = processIdle;
00331                                 a.Result = NULL;
00332                                 return a;
00333                         }
00334                 
00335                 case 7:
00336                         {
00337                                 DDigitalType *r = new DDigitalType(squareLength());
00338                                 r->incRef();
00339                                 IObjectIA::CProcessResult a;
00340                                 a.ResultState = processIdle;
00341                                 a.Result = r;
00342                                 return a;
00343                         }
00344 
00345                 case 8:
00346                         {
00347                                 DDigitalType *r = new DDigitalType(length());
00348                                 r->incRef();
00349                                 IObjectIA::CProcessResult a;
00350                                 a.ResultState = processIdle;
00351                                 a.Result = r;
00352                                 return a;
00353                         }
00354 
00355                 case 9:
00356                         {
00357                                 unit();
00358                                 IObjectIA::CProcessResult a;
00359                                 a.ResultState = processIdle;
00360                                 a.Result = NULL;
00361                                 return a;
00362                         }
00363 
00364                 default:
00365                         return IObjetOp::runMethodeMember(methodTag,p);
00366                         break;
00367                 }
00368         }
00369 
00370         /****************************************************
00371          * 
00372          */
00373         const IObjectIA::CProcessResult &VectorType::run()
00374         {
00375                 return IObjectIA::ProcessRun;
00376         }
00377 
00378         /****************************************************
00379          * 
00380          */
00381         const NLAIC::CIdentType &VectorType::getType() const
00382         {               
00383                 return IdVectorType;
00384         }
00385 
00386 }// Enf of the namespace "NLAIAGENT" //
00387 
00388 using namespace NLAIAGENT;
00389 const NLAIC::CIdentType VectorType::IdVectorType("Vector3D",NLAIC::CSelfClassFactory(VectorType(0, 0, 0)), 
00390                                                                                                                         NLAIC::CTypeOfObject(NLAIC::CTypeOfObject::tObject),
00391                                                                                                                         NLAIC::CTypeOfOperator(NLAIC::CTypeOfOperator::opAdd | 
00392                                                                                                                         NLAIC::CTypeOfOperator::opSub | 
00393                                                                                                                         NLAIC::CTypeOfOperator::opEq | 
00394                                                                                                                         NLAIC::CTypeOfOperator::opDiff));
00395
agent_3dvector.cpp
