WsfAdvancedBehaviorTree.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2021 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFADVANCEDBEHAVIORTREE_HPP
#define WSFADVANCEDBEHAVIORTREE_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <string>
#include <vector>
 
#include "WsfAdvancedBehaviorTreeNode.hpp"
#include "WsfObject.hpp"
#include "script/WsfScriptContext.hpp"
#include "script/WsfScriptObjectClass.hpp"
 
class UtInput;
class WsfAttributeContainer;
class WsfPlatform;
class WsfScenario;
class WsfScriptContext;
class WsfScriptProcessor;
class WsfSimulation;
 
 
class WSF_EXPORT WsfScriptAdvancedBehaviorTreeClass : public WsfScriptObjectClass
{
public:
   WsfScriptAdvancedBehaviorTreeClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);

   UtScriptContext* GetContext(void* aObjectPtr) override;
 
   // Script methods
   // Each of the exported methods are defined as function objects.
   UT_DECLARE_SCRIPT_METHOD(RootNode);
   UT_DECLARE_SCRIPT_METHOD(FindNode);
   UT_DECLARE_SCRIPT_METHOD(Id);
   UT_DECLARE_SCRIPT_METHOD(Name);
};
 
class WSF_EXPORT WsfAdvancedBehaviorTree : public WsfObject
{
   enum RootNodeType
   {
      PARALLEL,
      SEQUENCE,
      SEQUENCE_WITH_MEMORY,
      SELECTOR,
      SELECTOR_WITH_MEMORY,
      PRIORITY_SELECTOR,
      WEIGHTED_RANDOM
   };
 
public:
   WsfAdvancedBehaviorTree(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTree(const WsfAdvancedBehaviorTree& aSrc);
   ~WsfAdvancedBehaviorTree() override = default;
   WsfAdvancedBehaviorTree& operator=(const WsfAdvancedBehaviorTree& aRhs) = delete;

   void AddBlackboard(const std::string& aName, std::shared_ptr<WsfAttributeContainer> aBlackboardPtr);

   WsfAdvancedBehaviorTree* Clone() const override;

   WsfAttributeContainer* GetSharedBlackboard(const std::string& aName) const;

   std::vector<std::string> GetSharedBlackboardNames() const;

   WsfSimulation* GetSimulation();

   bool Initialize(double aSimTime, WsfScriptProcessor* aParentPtr, WsfScriptContext* aParentContextPtr = nullptr);

   const size_t NodeCount() const { return mBehaviorNodes.size(); }

   const unsigned int& GetTreeId() const { return mId; }

   const std::string& GetName() const { return mName; }

   static unsigned int GetUniqueTreeId() { return ++mNextUniqueId; }

   static void Reset() { mNextUniqueId = 0; }

   WsfAdvancedBehaviorTreeActionNode* NodeEntry(size_t aIndex) const;

   WsfScriptProcessor* GetParentProcessor() const { return mParentPtr; }

   bool ProcessInput(UtInput& aInput) override;

   void RegisterActionNode(WsfAdvancedBehaviorTreeActionNode* aNodePtr);

   std::shared_ptr<WsfAdvancedBehaviorTreeCompositeNode> RootNode() const { return mRootNodePtr; }

   const bool SharedBlackboardExists(const std::string& aName) const;

   void SetShouldOutputNextTick(const bool aValue) { mShouldOutput = aValue; }

   bool Tick(double aSimTime);

   WsfAdvancedBehaviorTreeNode* FindNode(const std::string& aNodeName) const;

   void FindLastExecuted(std::vector<WsfAdvancedBehaviorTreeNode*>& aLastExecuted) const;

   WsfPlatform* GetOwningPlatform() const;

   const char* GetScriptClassName() const override;

   const WsfScriptContext& GetScriptContext() const { return *mContextPtr; }

   void SetParent(WsfScriptProcessor* aParentPtr) { mParentPtr = aParentPtr; }

   void SetParentContext(WsfScriptContext* aParentContextPtr) { mContextPtr->SetParent(aParentContextPtr); }

   void SetRootNodeClass();

   void OutputTreeStructure(const double aSimTime);

   void OutputTreeState(const double aSimTime);

   void SetSuccessPolicy(const BT::SuccessPolicy aPolicy) { mSuccessPolicy = aPolicy; }

   void SetThreshold(const unsigned int aThreshold) { mThreshold = aThreshold; }
 
protected:
   UtScriptContext* GetScriptAccessibleContext() const override;

   bool RegisterExternVariable(const std::string& aVariableType, const std::string& aVariableName);
 
private:
   std::unique_ptr<WsfAdvancedBehaviorTreeNode> CreateNode(UtInput& aInput);

   bool ProcessTree(UtInput& aInput);

   const std::string GetFullFilePath(UtInput& aInput) const;
 
private:
   std::unique_ptr<WsfScriptContext>               mContextPtr{nullptr}; 
   std::vector<WsfAdvancedBehaviorTreeActionNode*> mBehaviorNodes; 
   std::map<std::string, std::shared_ptr<WsfAttributeContainer>> mBlackboards; 
   WsfScriptProcessor* mParentPtr; 
   std::shared_ptr<WsfAdvancedBehaviorTreeCompositeNode> mRootNodePtr; 
   bool                mShouldOutput; 
   bool                mOutputForBTT{false};           
   unsigned int        mId;                            
   std::string         mName;                          
   RootNodeType        mRootNodeType;                  
   BT::SuccessPolicy   mSuccessPolicy{BT::cTHRESHOLD}; 
   unsigned int        mThreshold{1};                  
   static unsigned int mNextUniqueId;                  
};
 
#endif // WSFADVANCEDBEHAVIORTREE_HPP