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 #ifndef NL_OPERATOR_CLASS
00027 #define NL_OPERATOR_CLASS
00028 
00029 #include "nel/ai/script/interpret_object_agent.h"
00030 #include "nel/ai/logic/goal.h"
00031 #include "nel/ai/logic/fact.h"
00032 #include "nel/ai/logic/var.h"
00033 #include "nel/ai/fuzzy/fuzzyset.h"
00034 
00035 namespace NLAISCRIPT
00036 {
00037         class COperatorClass: public CAgentClass
00038         {
00039         private:
00040                 NLAILOGIC::CGoal                                                        *_Goal;                         
00041 
00042                 const NLAIAGENT::IVarName                                       *_GoalAssert;           
00043                 std::list<const NLAIAGENT::IVarName *>          _GoalVars;                      
00044                 std::vector<sint32>                                                     _GoalPosVar;            
00045 
00046                 std::vector<NLAILOGIC::IBaseVar *>                      _Vars;                          
00047 
00048                 std::vector< NLAILOGIC::IBaseAssert *>          _Conds;                         
00049                 std::vector< std::vector<sint32> >                      _PosVarsCond;           
00050 
00051                 std::vector<NLAILOGIC::IBaseAssert *>           _Concs;                         
00052                 std::vector< std::vector<sint32> >                      _PosVarsConc;           
00053 
00054                 std::vector<NLAIAGENT::IMessageBase::TPerformatif>      _TrigMsgPerf;
00055                 std::vector<NLAIC::CIdentType>                          _TrigMsgClass;
00056                 std::vector<std::string>                                        _TrigMsgVarname;
00057                 std::vector<sint32>                                                     _TrigMsgPos;
00058 
00059                 char                                                                            *_Comment;                      
00060 
00061                 std::vector<NLAILOGIC::CGoal>                           _Steps;                         // Successive goals to be achieved
00062                 std::vector<sint32>                                                     _StepsMode;                     // Infos about synchro for the steps of the operator
00063 
00064                 sint32                                                                          _UpdateCycles;          // Number of cycles before checking preconditions
00065 
00066                 float                                                                           _Priority;
00067 
00068         public:
00069                 static const NLAIC::CIdentType IdOperatorClass;
00070                 
00072                 void setComment(char *);
00073 
00075 //              virtual void setGoal(NLAILOGIC::CGoal *);
00076                 virtual void setGoal(const NLAIAGENT::CStringVarName &);
00077                 virtual void setGoal(const NLAIAGENT::IVarName *, std::list<const NLAIAGENT::IVarName *> &);
00078                 virtual const NLAILOGIC::CGoal *getGoal();
00079 
00081                 virtual bool isValid(NLAILOGIC::CFactBase *);
00082 
00084                 void compileFactPattern (NLAILOGIC::CFactPattern   *, std::vector<NLAILOGIC::IBaseAssert *> &, std::vector<sint32> &);
00085 
00086                 // Buils a CFact from its assret and an instanciation for the values of the variables of the rule.
00087                 NLAILOGIC::CFact *buildFromVars(NLAILOGIC::IBaseAssert *, std::vector<sint32> &, NLAILOGIC::CValueSet *);
00088 
00090                 sint32 getVarPos(NLAILOGIC::IBaseVar *);
00091 
00093                 NLAILOGIC::CValueSet *unifyLiaison( const NLAILOGIC::CValueSet *, NLAILOGIC::CValueSet *, std::vector<sint32> &);
00094 
00095                 void getPosListForward(sint32, sint32, std::vector<sint32> &);
00096                 void getPosListBackward(sint32, sint32, std::vector<sint32> &);
00097                 void getAssertPos(NLAILOGIC::IBaseAssert *, std::vector<NLAILOGIC::IBaseAssert *> &, std::vector<sint32> &);
00098                 NLAILOGIC::CValueSet *unifyBackward(std::list<NLAILOGIC::CFact *> &);
00099                 NLAILOGIC::CValueSet *unifyForward(std::list<NLAILOGIC::CFact *> &);
00100 
00101                 virtual std::list<NLAILOGIC::CFact *> *test(std::list<NLAILOGIC::CFact *> &) {return NULL;}
00102                 virtual std::list<NLAILOGIC::CFact *> *backward(std::list<NLAILOGIC::CFact *> &);
00103                 virtual std::list<NLAILOGIC::CFact *> *forward(std::list<NLAILOGIC::CFact *> &);
00104                 virtual std::list<NLAILOGIC::CFact *> *propagate(std::list<NLAILOGIC::CFact *> &);
00105 
00107                 virtual float priority() const;
00108 
00112                 virtual void success();
00113                 virtual void failure();
00114 
00117                 virtual void success( NLAILOGIC::IBaseOperator *);
00118                 virtual void failure( NLAILOGIC::IBaseOperator *);
00119 
00120 public:
00121                 COperatorClass(const NLAIAGENT::IVarName &);
00122                 COperatorClass(const NLAIC::CIdentType &);
00123                 COperatorClass(const NLAIAGENT::IVarName &, const NLAIAGENT::IVarName &);
00124                 COperatorClass(const COperatorClass &);
00125                 COperatorClass();
00126                 virtual ~COperatorClass();
00127 
00128                 const NLAIC::IBasicType *clone() const;
00129                 const NLAIC::IBasicType *newInstance() const;
00130                 virtual void getDebugString(std::string &) const;
00131 
00132                 virtual NLAIAGENT::IObjectIA *buildNewInstance() const;
00133 
00134 
00135                 void addPrecondition(NLAILOGIC::CFactPattern *);
00136                 void addPostcondition(NLAILOGIC::CFactPattern *);
00137 
00141 
00142                 // Logique
00143                 std::list<const NLAIAGENT::IVarName *> _BooleanConds;
00144                 std::list<const NLAIAGENT::IVarName *> _BooleanConcs;
00145                 std::vector<const NLAIAGENT::IVarName *> _CondAsserts;
00146                 std::vector<const NLAIAGENT::IVarName *> _ConcAsserts;
00147                 std::vector< std::list<const NLAIAGENT::IVarName *> *> _ClassCondVars;
00148                 std::vector< std::list<const NLAIAGENT::IVarName *> *> _ClassConcVars;
00149                 std::vector< IOpCode *> _CondCode;
00150                 std::vector< IOpCode *> _ConcCode;
00151 
00152                 NLAILOGIC::CFactBase *_FactBase;
00153 
00154                 std::vector<NLAIAGENT::IVarName *> _FuzzyVars;
00155                 std::vector<NLAIAGENT::IVarName *> _FuzzySets;
00156         //      NLAIAGENT::CStringVarName *_GoalName;
00158 
00159 /*
00161                 void addPrecondition(NLAILOGIC::CFactPattern   *);
00162 
00164                 void addPostcondition(NLAILOGIC::CFactPattern   *);
00165 */
00166 //              virtual ~COperatorClass();
00167 
00169                 void addFirstOrderCond(const NLAIAGENT::IVarName *, std::list<const NLAIAGENT::IVarName *> &);
00170                 void addFirstOrderConc(const NLAIAGENT::IVarName *, std::list<const NLAIAGENT::IVarName *> &);
00171 
00173                 void addBoolCond(const NLAIAGENT::IVarName *);
00174                 void addBoolConc(const NLAIAGENT::IVarName *);
00175 
00178                 void addCodeCond(IOpCode *);
00180                 void addCodeConc(IOpCode *);
00181 
00182                 // Adds a fuzzy cond of the form <attrib> is <filter>
00183                 void addFuzzyCond(NLAIAGENT::IVarName *, NLAIAGENT::IVarName *);
00184 
00186                 void buildLogicTables();
00187 
00188                 bool isValidFonc(NLAIAGENT::IObjectIA *);
00189                 void activatePostConditions(NLAIAGENT::IObjectIA *);
00190 
00191                 void initialiseFactBase(NLAILOGIC::CFactBase *);
00192 
00193                 std::vector<NLAIAGENT::IVarName *> &getFuzzyVars()
00194                 {
00195                         return _FuzzyVars;
00196                 }
00197 
00198                 std::vector<NLAIAGENT::IVarName *> &getFuzzySets()
00199                 {
00200                         return _FuzzySets;
00201                 }
00202 
00203                 std::vector<NLAILOGIC::IBaseVar *>      &getVars()
00204                 {
00205                         return _Vars;
00206                 }
00207 
00208                 std::vector< NLAILOGIC::IBaseAssert *>  &getConds()
00209                 {
00210                         return _Conds;
00211                 }
00212 
00213                 std::vector< NLAILOGIC::IBaseAssert *>  &getConcs()
00214                 {
00215                         return _Concs;
00216                 }
00217 
00218                 std::vector< std::vector<sint32> >      &getPosVarsConds()
00219                 {
00220                         return _PosVarsCond;
00221                 }
00222 
00223                 std::vector< std::vector<sint32> >      &getPosVarsConcs()
00224                 {
00225                         return _PosVarsConc;
00226                 }
00227 
00228                 std::vector<sint32> &getGoalVarPos()
00229                 {
00230                         return _GoalPosVar;
00231                 }
00232 
00233                 virtual void setUpdateEvery(sint32 cycles)
00234                 {
00235                         _UpdateCycles = cycles;
00236                 }
00237 
00238                 sint32 getUpdateEvery()
00239                 {
00240                         return _UpdateCycles;
00241                 }
00242 
00243                 void setPriority(float p)
00244                 {
00245                         _Priority = p;
00246                 }
00247 
00248                 float getPriority() const
00249                 {
00250                         return _Priority;
00251                 }
00252 
00253                 void RegisterMessage(NLAIAGENT::IMessageBase::TPerformatif , const std::string &, const std::string & );
00254                 virtual sint32 checkTriggerMsg(const NLAIAGENT::IMessageBase *);
00255                 inline sint32 NbMsgTrigger()
00256                 {
00257                         return _TrigMsgPerf.size();
00258                 }
00259         };
00260 }
00261 #endif
interpret_object_operator.h
