nevrax.org : docs

00001 
00008 /* Copyright, 2000 Nevrax Ltd.
00009  *
00010  * This file is part of NEVRAX NEL.
00011  * NEVRAX NEL is free software; you can redistribute it and/or modify
00012  * it under the terms of the GNU General Public License as published by
00013  * the Free Software Foundation; either version 2, or (at your option)
00014  * any later version.
00015 
00016  * NEVRAX NEL is distributed in the hope that it will be useful, but
00017  * WITHOUT ANY WARRANTY; without even the implied warranty of
00018  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00019  * General Public License for more details. 
00020 
00021  * You should have received a copy of the GNU General Public License
00022  * along with NEVRAX NEL; see the file COPYING. If not, write to the
00023  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
00024  * MA 02111-1307, USA.
00025  */
00026 
00027 #ifndef NL_ACTOR_SCRIPT_H_
00028 #define NL_ACTOR_SCRIPT_H_
00029 
00030 #include "nel/ai/agent/agent.h"
00031 #include "nel/ai/agent/agent_script.h"
00032 #include "nel/ai/agent/agent_manager.h"
00033 #include "nel/ai/logic/bool_cond.h"
00034 #include "nel/ai/script/type_def.h"
00035 #include "nel/ai/script/interpret_actor.h"
00036 
00037 namespace NLAIAGENT
00038 {
00039 
00040         class CComponentHandle/* : public IObjectIA */{
00041                 private:
00042                         IVarName                *_CompName;
00043                         const IObjectIA *_Comp;
00044                         IAgent                  *_CompFather;
00045 
00046                 public:
00047                         CComponentHandle()
00048                         {
00049                                 _Comp = NULL;
00050                                 _CompFather = NULL;
00051                         }
00052 
00053                         ~CComponentHandle()
00054                         {
00055 //                              if ( _Comp )
00056 //                                      _Comp->release();
00057                         }
00058 
00059 
00060                         CComponentHandle(const IVarName &comp_name, IAgent *comp_father , bool get = false)
00061                         {
00062                                 _CompName = (IVarName *) comp_name.clone();
00063                                 _CompFather = comp_father;
00064                                 if ( get )
00065                                         getComponent();
00066                                 else
00067                                         _Comp = NULL;
00068                         }
00069 
00070                         void getComponent()
00071                         {
00072                                 if ( _CompFather )
00073                                 {
00074 
00075 #ifdef _DEBUG
00076                                         const char *dbg_father_type = (const char *) _CompFather->getType();
00077                                         const char *dbg_comp_name = (const char *) _CompName->getType();
00078                                         char buffer[1024 * 8];
00079                                         _CompName->getDebugString(buffer);
00080 #endif
00081 
00082                                         // Looks in static components
00083                                         sint32 comp_id = _CompFather->getStaticMemberIndex( *_CompName );
00084                                         if ( comp_id >= 0)
00085                                                 _Comp = _CompFather->getStaticMember( comp_id );
00086                                         else
00087                                                 _Comp = NULL;
00088 
00089                                         if ( _Comp == NULL )
00090                                         {
00091                                                 // Looks in dynamic component
00092                                                 CGroupType *param = new CGroupType();
00093                                                 param->push( (IObjectIA *) _CompName );
00094                                                 IObjectIA::CProcessResult comp = ( (CAgentScript *) _CompFather)->getDynamicAgent(param);
00095                                                 param->pop();
00096                                                 delete param;
00097                                                 if ( comp.Result )
00098                                                         _Comp = comp.Result;
00099                                                 else
00100                                                         _Comp = NULL;
00101                                         }
00102                                 }
00103                         }
00104 
00105                         const IObjectIA *getValue()
00106                         {
00107                                 if ( _Comp )
00108                                         return _Comp;
00109                                 
00110                                 getComponent();
00111                                 return _Comp;
00112                         }
00113         };
00114 
00115 
00125         class CActorScript  : public CAgentScript
00126         {
00127                 protected:
00128 
00129                         enum c_funcs_id 
00130                         {
00131                                 fid_activate,
00132                                 fid_onActivate,
00133                                 fid_unActivate,
00134                                 fid_onUnActivate,
00135                                 fid_switch,
00136                                 fid_last
00137                         };
00138 
00139                         bool _IsActivated;
00140                         sint32  _OnActivateIndex;
00141                         sint32  _OnUnActivateIndex;
00142                         std::vector<CComponentHandle *> _Actors;
00143                         
00147                         virtual void switchActor(CActorScript *, bool stay_active = false);
00151                         virtual void switchActor(std::vector<CActorScript *> &, bool stay_active = false);
00155                         virtual void switchActor(std::vector<CComponentHandle *> &, bool stay_active = false);
00156 
00157 
00158                 public:
00159                         // Builds and actor with its father
00160                         CActorScript(IAgentManager *, bool activated = false);
00161                         // copy constructor
00162                         CActorScript(const CActorScript &);
00163                         CActorScript(IAgentManager *, IBasicAgent *, std::list<IObjectIA *> &, NLAISCRIPT::CActorClass *);
00164                         virtual ~CActorScript();
00165 
00167                         bool isActivated();
00169 
00171                         void activate();
00173                         virtual void onActivate();
00174 
00176                         void unActivate();
00178                         virtual void onUnActivate();
00179                         
00180                         virtual int getBaseMethodCount() const;
00181 
00183                         virtual const NLAIC::IBasicType *clone() const;
00184                         virtual const NLAIC::IBasicType *newInstance() const;
00185                         virtual void getDebugString(char *t) const;
00186                         virtual bool isEqual(const IBasicObjectIA &a) const;
00187                         virtual void processMessages();
00188                         virtual const CProcessResult &run();
00189 
00190 //                      virtual IObjectIA *run(const IMessageBase &msg);
00191                         virtual CProcessResult sendMessage(IObjectIA *);
00192                         virtual const NLAIC::CIdentType &getType() const;
00193 
00194                         static const NLAIC::CIdentType IdActorScript;
00195 
00196                         virtual void save(NLMISC::IStream &os);         
00197                         virtual void load(NLMISC::IStream &is);         
00198 
00199                         virtual IObjectIA::CProcessResult runMethodBase(int heritance, int index,IObjectIA *);
00200                         virtual IObjectIA::CProcessResult runMethodBase(int index,IObjectIA *);
00201 
00202                         virtual tQueue isMember(const NLAIAGENT::IVarName *, const NLAIAGENT::IVarName *, const IObjectIA &) const;
00203 //                      virtual IObjectIA::CProcessResult runMethodeMember(sint32, sint32, IObjectIA *);
00204 //                      virtual IObjectIA::CProcessResult runMethodeMember(sint32, IObjectIA *);
00205                         virtual sint32 getMethodIndexSize() const;
00206 
00207                         void getFatherComponent(IVarName &);
00208         };
00209 }
00210 #endif
actor_script.h
