00001 #include "nel/ai/agent/actor.h"
00002 #include "nel/ai/agent/agent_script.h"
00003 #include "nel/ai/agent/object_type.h"
00004
00005 namespace NLAIAGENT
00006 {
00007
00008
00010 CActor::CActor() : IAgent(NULL)
00011 {
00012 }
00013
00015 CActor::CActor(IAgent *father, bool activated) : IAgent( father )
00016 {
00017 _IsActivated = activated;
00018 }
00019
00021 CActor::CActor(const CActor &c) : IAgent( c )
00022 {
00023 _IsActivated = c._IsActivated;
00024 }
00025
00026 CActor::~CActor()
00027 {
00028
00029
00030 }
00031
00033 bool CActor::isActivated()
00034 {
00035 return _IsActivated;
00036 }
00037
00039 void CActor::activate()
00040 {
00041 if ( !_IsActivated )
00042 {
00043 onActivate();
00044 _IsActivated = true;
00045 }
00046 }
00047
00049 void CActor::unActivate()
00050 {
00051 if ( _IsActivated )
00052 {
00053 onUnActivate();
00054 _IsActivated = false;
00055 }
00056 }
00057
00061 void CActor::forwardActivity(CActor *receiver, bool stay_active)
00062 {
00063 receiver->activate();
00064
00065 if ( !stay_active )
00066 unActivate();
00067 }
00068
00072 void CActor::forwardActivity(std::vector<CActor *> &actors, bool stay_active)
00073 {
00074 std::vector<CActor *>::iterator it_act = actors.begin();
00075 while ( it_act != actors.end() )
00076 {
00077 ( *it_act )->activate();
00078 it_act++;
00079 }
00080
00081 if ( !stay_active )
00082 unActivate();
00083 }
00084
00086 void CActor::addTransition(NLAILOGIC::IBaseCond *cond, std::vector<CActor *> &outputs, bool stay_alive)
00087 {
00088
00089 }
00090
00091
00092
00093
00094
00095
00097 void CActor::onActivate()
00098 {
00099
00100 }
00102 void CActor::onUnActivate()
00103 {
00104
00105 }
00106
00107 const NLAIC::IBasicType *CActor::clone() const
00108 {
00109 CActor *m = new CActor(*this);
00110 return m;
00111 }
00112
00113 const NLAIC::IBasicType *CActor::newInstance() const
00114 {
00115 NLAIC::IBasicInterface *m;
00116 if ( getParent() != NULL )
00117 m = new CActor((IAgent *)getParent());
00118 else
00119 m = new CActor(NULL);
00120 return m;
00121 }
00122
00123 void CActor::getDebugString(char *t) const
00124 {
00125 strcpy(t,"CActor ");
00126 if ( _IsActivated )
00127 strcat(t, "<active>");
00128 else
00129 strcat(t, "<idle>");
00130 }
00131
00132 bool CActor::isEqual(const IBasicObjectIA &a) const
00133 {
00134 return true;
00135 }
00136
00137 void CActor::processMessages()
00138 {
00139 IAgent::processMessages();
00140 00141 00142 00143 00144 00145
00146 }
00147
00148 const IObjectIA::CProcessResult &CActor::run()
00149 {
00150 if ( _IsActivated )
00151 {
00152 return IAgent::run();
00153 }
00154 else
00155 return IObjectIA::ProcessRun;
00156 00157 00158 00159 00160 00161 00162 00163 00164 00165 00166
00167 }
00168
00169 00170 00171 00172
00173
00174 const NLAIC::CIdentType &CActor::getType() const
00175 {
00176 return IdActor;
00177 }
00178
00179 void CActor::save(NLMISC::IStream &os)
00180 {
00181 IAgent::save(os);
00182 os.serial( (bool &) _IsActivated );
00183
00184 }
00185
00186 void CActor::load(NLMISC::IStream &is)
00187 {
00188 IAgent::load(is);
00189 }
00190
00191 tQueue CActor::isMember(const IVarName *className,const NLAIAGENT::IVarName *name,const IObjectIA ¶m) const
00192 {
00193 tQueue result;
00194
00195 result = IAgent::isMember( className, name, param );
00196
00197 if ( result.size() )
00198 return result;
00199
00200
00201
00202 if ( *name == CStringVarName("activate") )
00203 {
00204 CObjectType *r_type = new CObjectType( new NLAIC::CIdentType( NLAIC::CIdentType::VoidType ) );
00205 result.push( NLAIAGENT::CIdMethod( fid_activate + IAgent::getMethodIndexSize(), 0.0,NULL, r_type ) );
00206 }
00207
00208 if ( *name == CStringVarName("unActivate") )
00209 {
00210 CObjectType *r_type = new CObjectType( new NLAIC::CIdentType( NLAIC::CIdentType::VoidType ) );
00211 result.push( NLAIAGENT::CIdMethod( fid_unActivate + IAgent::getMethodIndexSize(), 0.0,NULL, r_type ) );
00212 }
00213
00214 if ( *name == CStringVarName("forwardActivity") )
00215 {
00216 CObjectType *r_type = new CObjectType( new NLAIC::CIdentType( NLAIC::CIdentType::VoidType ) );
00217 result.push( NLAIAGENT::CIdMethod( fid_forwardActivity + IAgent::getMethodIndexSize(), 0.0,NULL, r_type ) );
00218 }
00219
00220 return result;
00221 }
00222
00223
00224 IObjectIA::CProcessResult CActor::runMethodeMember(sint32 id, IObjectIA *params)
00225 {
00226 if ( id < IAgent::getMethodIndexSize() )
00227 return IAgent::runMethodeMember(id, params);
00228
00229 IObjectIA::CProcessResult r;
00230
00231 char buf[1024];
00232 getDebugString(buf);
00233
00234 id = id - IAgent::getMethodIndexSize();
00235
00236 if ( id == fid_activate )
00237 {
00238 activate();
00239 IObjectIA::CProcessResult r;
00240 r.ResultState = NLAIAGENT::processIdle;
00241 r.Result = NULL;
00242 }
00243
00244 if ( id == fid_unActivate )
00245 {
00246 unActivate();
00247 IObjectIA::CProcessResult r;
00248 r.ResultState = NLAIAGENT::processIdle;
00249 r.Result = NULL;
00250 }
00251
00252 if ( id == fid_forwardActivity )
00253 {
00254 std::vector<CActor *> forwarded;
00255 if ( ( (NLAIAGENT::IBaseGroupType *) params)->size() )
00256 {
00257 IBaseGroupType *fw = (IBaseGroupType *) ( ((NLAIAGENT::IBaseGroupType *)params) )->getFront();
00258 ( ((NLAIAGENT::IBaseGroupType *)params))->popFront();
00259 while ( fw->size() )
00260 {
00261 forwarded.push_back( (CActor *) fw->getFront() );
00262 fw->popFront();
00263 }
00264 forwardActivity( forwarded, false );
00265 }
00266 IObjectIA::CProcessResult r;
00267 r.ResultState = NLAIAGENT::processIdle;
00268 r.Result = NULL;
00269 }
00270 return r;
00271 }
00272
00273 sint32 CActor::getMethodIndexSize() const
00274 {
00275 return IAgent::getMethodIndexSize() + 2;
00276 }
00277 }