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 NLIACeral 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  * NLIACeral 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 #ifndef NL_GOAL_
00027 #define NL_GOAL_
00028 
00029 #include "nel/ai/logic/boolval.h"
00030 #include "nel/ai/agent/agent.h"
00031 
00032 
00033 namespace NLAIAGENT
00034 {
00035         class COperatorScript;
00036 }
00037 
00038 namespace NLAILOGIC 
00039 {
00040         class IBaseOperator;
00041 
00042 
00043         class IGoal : public IBaseBoolType
00044         {
00045 
00046                 public:
00047                         enum TTypeOfGoal
00048                         {
00049                                 achieveOnce,
00050                                 achieveForever
00051                         };
00052 
00053 
00054                         enum TPriority
00055                         {
00056                                 Normal,
00057                                 Order,
00058                                 Urgent
00059                         };
00060 
00061                 protected:
00062                         NLAIAGENT::IVarName *_Name;
00063                         std::vector<NLAIAGENT::IObjectIA *>             _Args;
00064                         std::vector<NLAIAGENT::IBasicAgent *>   _Predecessors;
00065                         std::vector<NLAIAGENT::IBasicAgent *>   _Successors;
00066 
00067                         TTypeOfGoal     _Mode;
00068 
00069                         bool _Selected;
00070 
00071                         float _Priority;
00072 
00073                         NLAIAGENT::IBasicAgent *_Sender;
00074                         NLAIAGENT::IBasicAgent *_Receiver;
00075 
00076                 public:
00077                         IGoal();
00078                         IGoal(const NLAIAGENT::IVarName &, TTypeOfGoal mode = achieveOnce);
00079                         IGoal(const NLAIAGENT::IVarName &, std::list<const NLAIAGENT::IObjectIA *> &,TTypeOfGoal mode = achieveOnce);
00080                         IGoal(const IGoal &);
00081                         virtual ~IGoal();
00082 
00083                         const NLAIAGENT::IVarName &getName() const
00084                         {
00085                                 return *_Name;
00086                         }
00087 
00088                         void setMode(TTypeOfGoal mode)
00089                         {
00090                                 _Mode = mode;
00091                         }
00092 
00093                         virtual void select()
00094                         {
00095                                 _Selected = true;
00096                         }
00097 
00098                         virtual void unSelect()
00099                         {
00100                                 _Selected = false;
00101                         }
00102 
00103                         bool isSelected()
00104                         {
00105                                 return _Selected;
00106                         }
00107 
00108                         bool isActivable()
00109                         {
00110                                 return ( !_Successors.empty() );
00111                         }
00112 
00113                         virtual void failure();
00114                         virtual void success();
00115 
00116                         virtual void operatorSuccess(NLAIAGENT::IBasicAgent *);
00117                         virtual void operatorFailure(NLAIAGENT::IBasicAgent *);
00118 
00119                         bool isExclusive();
00120 
00121                         virtual void setPriority(float);
00122                         virtual void calcPriority();
00123                         virtual float getPriority();
00124 
00125                         void setSender(NLAIAGENT::IBasicAgent *);
00126                         void setReceiver(NLAIAGENT::IBasicAgent *);
00127                         NLAIAGENT::IBasicAgent *getSender();
00128                         NLAIAGENT::IBasicAgent *getReceiver();
00129         };
00130 
00131         class CGoal : public IGoal
00132         {
00133                 public:
00134 
00135                         CGoal();
00136                         CGoal(const NLAIAGENT::IVarName &, TTypeOfGoal mode = achieveOnce);
00137                         CGoal(const NLAIAGENT::IVarName &, std::list<const NLAIAGENT::IObjectIA *> &,TTypeOfGoal mode = achieveOnce);
00138                         CGoal(const CGoal &);
00139                         virtual ~CGoal();
00140 
00141                         void setArgs(std::list<NLAIAGENT::IObjectIA *> &);
00142                         const std::vector<NLAIAGENT::IObjectIA *> &getArgs();
00143 
00144                         static const NLAIC::CIdentType IdGoal;
00145 
00146                         void addSuccessor(NLAIAGENT::IBasicAgent *);
00147                         void addPredecessor(NLAIAGENT::IBasicAgent *);
00148 
00149 //                      virtual void failure();
00150 //                      virtual void success();
00151 
00152                         virtual void operatorSuccess(NLAIAGENT::IBasicAgent *);
00153                         virtual void operatorFailure(NLAIAGENT::IBasicAgent *);
00154 
00155                         const std::vector<IBaseOperator *> getOperators();
00156 
00157                         const NLAIC::IBasicType *clone() const;
00158                         const NLAIC::IBasicType *newInstance() const;
00159                         void save(NLMISC::IStream &os);
00160                         void load(NLMISC::IStream &is);
00161                         virtual void getDebugString(std::string &) const;
00162                         bool isTrue() const;
00163                         float truthValue() const;
00164                         const IObjectIA::CProcessResult &run();
00165                         bool isEqual(const CGoal &a) const;
00166                         bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const;
00167                         const NLAIC::CIdentType &getType() const;
00168 
00169                         virtual NLAIAGENT::tQueue isMember(const NLAIAGENT::IVarName *,const NLAIAGENT::IVarName *,const NLAIAGENT::IObjectIA &) const;
00170                         virtual NLAIAGENT::IObjectIA::CProcessResult runMethodeMember(sint32, sint32, NLAIAGENT::IObjectIA *);
00171                         virtual NLAIAGENT::IObjectIA::CProcessResult runMethodeMember(sint32 index, NLAIAGENT::IObjectIA *p);
00172                         sint32 getMethodIndexSize() const;
00173 
00174 
00175                         virtual bool operator==(const CGoal &);
00176 
00177                         virtual void cancel();
00178                         virtual float priority() const;
00179 
00180 /*                      virtual void setTopLevel(NLAIAGENT::CAgentScript *);
00181                         const NALAIGENT::CAgentScript *getTOpLevel() const;*/
00182 
00183         };
00184 
00185         class CInternalGoal : public IGoal
00186         {
00187                 private:
00188                         NLAIAGENT::IObjectIA *_Property;
00189                 public:
00190 
00191                         CInternalGoal();
00192                         CInternalGoal(const NLAIAGENT::IVarName &, TTypeOfGoal mode = achieveOnce);
00193                         CInternalGoal(const NLAIAGENT::IVarName &, std::list<const NLAIAGENT::IObjectIA *> &,TTypeOfGoal mode = achieveOnce);
00194                         CInternalGoal(const CInternalGoal &);
00195                         virtual ~CInternalGoal();
00196 
00197                         void setArgs(std::list<NLAIAGENT::IObjectIA *> &);
00198                         const std::vector<NLAIAGENT::IObjectIA *> &getArgs();
00199 
00200                         static const NLAIC::CIdentType IdInternalGoal;
00201 
00202                         void addSuccessor(NLAIAGENT::IBasicAgent *);
00203                         void addPredecessor(NLAIAGENT::IBasicAgent *);
00204 
00205 //                      virtual void failure();
00206 //                      virtual void success();
00207 
00208                         virtual void operatorSuccess(NLAIAGENT::IBasicAgent *);
00209                         virtual void operatorFailure(NLAIAGENT::IBasicAgent *);
00210 
00211                         const std::vector<IBaseOperator *> getOperators();
00212 
00213                         const NLAIC::IBasicType *clone() const;
00214                         const NLAIC::IBasicType *newInstance() const;
00215                         void save(NLMISC::IStream &os);
00216                         void load(NLMISC::IStream &is);
00217                         virtual void getDebugString(std::string &) const;
00218                         bool isTrue() const;
00219                         float truthValue() const;
00220                         const IObjectIA::CProcessResult &run();
00221                         bool isEqual(const CInternalGoal &a) const;
00222                         bool isEqual(const NLAIAGENT::IBasicObjectIA &a) const;
00223                         const NLAIC::CIdentType &getType() const;
00224 
00225                         virtual NLAIAGENT::tQueue isMember(const NLAIAGENT::IVarName *,const NLAIAGENT::IVarName *,const NLAIAGENT::IObjectIA &) const;
00226                         virtual NLAIAGENT::IObjectIA::CProcessResult runMethodeMember(sint32, sint32, NLAIAGENT::IObjectIA *);
00227                         virtual NLAIAGENT::IObjectIA::CProcessResult runMethodeMember(sint32 index, NLAIAGENT::IObjectIA *p);
00228                         sint32 getMethodIndexSize() const;
00229 
00230 
00231                         virtual bool operator==(const CInternalGoal &);
00232 
00233                         void setSender(NLAIAGENT::IBasicAgent *);
00234                         void setReceiver(NLAIAGENT::IBasicAgent *);
00235 
00236                         NLAIAGENT::IBasicAgent *getSender();
00237                         NLAIAGENT::IBasicAgent *getReceiver();
00238 
00239                         virtual void cancel();
00240                         virtual float priority() const;
00241 
00242                         void setProperty(NLAIAGENT::IObjectIA *);
00243         };
00244 }
00245 
00246 #endif
goal.h
