WsfAdvancedBehaviorTreeNode.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 WSFADVANCEDBEHAVIORTREENODE_HPP
#define WSFADVANCEDBEHAVIORTREENODE_HPP
 
#include "wsf_export.h"
 
#include <string>
#include <vector>
 
#include "UtColor.hpp"
#include "WsfEventPipeClasses.hpp"
#include "WsfObject.hpp"
#include "WsfObjectTypeList.hpp"
#include "script/WsfScriptObjectClass.hpp"
 
class UtInput;
class WsfAdvancedBehaviorTree;
class WsfAttributeContainer;
class WsfMessage;
class WsfPlatform;
class WsfScript;
class WsfScriptContext;
class WsfScriptMessageHandler;
class WsfScriptProcessor;
class WsfScriptStateMachine;
class WsfSimulation;
 
namespace BT
{
enum ReturnStatus
{
   cRUNNING  = 1,
   cSUCCESS  = 2,
   cFAILURE  = 3,
   cIDLE     = 4,
   cHALTED   = 5,
   cDISABLED = 6
};

enum SuccessPolicy
{
   cSUCCEED_ON_ONE,
   cSUCCEED_ON_ALL,
   cTHRESHOLD
};

enum FailurePolicy
{
   cFAIL_ON_ONE,
   cFAIL_ON_ALL
};

enum ResetPolicy
{
   cON_SUCCESS_OR_FAILURE,
   cON_SUCCESS,
   cON_FAILURE
};
} // namespace BT
 
class WSF_EXPORT WsfScriptAdvancedBehaviorTreeNodeClass : public WsfScriptObjectClass
{
public:
   WsfScriptAdvancedBehaviorTreeNodeClass(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(Failure_1);
   UT_DECLARE_SCRIPT_METHOD(Failure_2);
   UT_DECLARE_SCRIPT_METHOD(Type);
   UT_DECLARE_SCRIPT_METHOD(Id);
   UT_DECLARE_SCRIPT_METHOD(Running_1);
   UT_DECLARE_SCRIPT_METHOD(Running_2);
   UT_DECLARE_SCRIPT_METHOD(Success_1);
   UT_DECLARE_SCRIPT_METHOD(Success_2);
   UT_DECLARE_SCRIPT_METHOD(TurnOff);
   UT_DECLARE_SCRIPT_METHOD(TurnOn);
   UT_DECLARE_SCRIPT_METHOD(State);
   UT_DECLARE_SCRIPT_METHOD(Tree);
 
   // Blackboard methods
   UT_DECLARE_SCRIPT_METHOD(BlackboardVarExists);
   UT_DECLARE_SCRIPT_METHOD(CreateSharedBlackboard);
   UT_DECLARE_SCRIPT_METHOD(DeleteBlackboardVar);
   UT_DECLARE_SCRIPT_METHOD(DeleteSharedBlackboardVar);
   UT_DECLARE_SCRIPT_METHOD(GetBlackboardVar);
   UT_DECLARE_SCRIPT_METHOD(GetSharedBlackboardVar);
   UT_DECLARE_SCRIPT_METHOD(SetBlackboardVar);
   UT_DECLARE_SCRIPT_METHOD(SetBlackboardTrackVar);
   UT_DECLARE_SCRIPT_METHOD(SetBlackboardPlatformVar);
   UT_DECLARE_SCRIPT_METHOD(SetSharedBlackboardVar);
   UT_DECLARE_SCRIPT_METHOD(SetSharedBlackboardTrackVar);
   UT_DECLARE_SCRIPT_METHOD(SetSharedBlackboardPlatformVar);
   UT_DECLARE_SCRIPT_METHOD(ShareBlackboard);
   UT_DECLARE_SCRIPT_METHOD(ShareBlackboardWithName);
   UT_DECLARE_SCRIPT_METHOD(SharedBlackboardExists);
   UT_DECLARE_SCRIPT_METHOD(SharedBlackboardVarExists);
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeNode : public WsfObject
{
public:
   WsfAdvancedBehaviorTreeNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeNode(const WsfAdvancedBehaviorTreeNode& aSrc);
   ~WsfAdvancedBehaviorTreeNode() override;
   WsfAdvancedBehaviorTreeNode& operator=(const WsfAdvancedBehaviorTreeNode&) = delete;

   virtual void AddChild(std::shared_ptr<WsfAdvancedBehaviorTreeNode> aNodePtr) {}

   virtual void AddTree(ut::CloneablePtr<WsfAdvancedBehaviorTree>& aTreePtr) {}

   virtual std::vector<std::shared_ptr<WsfAdvancedBehaviorTreeNode>>& GetChildren()
   {
      throw std::logic_error("This node doesn't have children!");
   }

   virtual std::map<size_t, ut::CloneablePtr<WsfAdvancedBehaviorTree>>& GetTrees()
   {
      throw std::logic_error("This node doesn't have children trees!");
   }

   virtual void OutputTreeStructures(const double aSimTime) {}

   virtual void OutputTreeStates(const double aSimTime) {}

   WsfAdvancedBehaviorTreeNode* Clone() const override = 0;

   virtual const int GetDepth() const { return 0; }

   const time_t& GetFileLastModTime() const { return mFileLastModTime; }

   const std::string& GetFilePath() const { return mFullPathFileName; }

   std::shared_ptr<WsfAttributeContainer> GetBlackboard() { return mBlackboard; }

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

   void SetNodeName(const std::string& aName);

   const std::string& GetDescription() const { return mDescription; }

   void SetDescription(const std::string& aDesc) { mDescription = aDesc; }

   const BT::ReturnStatus& GetNodeStatus() const { return mReturnStatus; }

   const WsfScenario& GetScenario() const { return mScenario; }

   const char* GetScriptClassName() const override;

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

   WsfSimulation* GetSimulation() const;

   const std::string& GetPreconditionTooltip() const { return mPreconditionTooltip; }

   const std::string& GetExecuteTooltip() const { return mExecuteTooltip; }

   const bool& GetTurnedOn() const { return mTurnedOn; };

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

   virtual void Halt(const std::string& aReason) {}

   virtual void HaltChildren(unsigned int aIndex, const std::string& aReason) {}

   virtual const bool HasChildrenContainer() const { return false; };

   const bool& HasParent() const { return mHasParent; }

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

   const UtColor& GetColor() const { return mColor; }

   bool HasDefinedColor() const { return mHasDefinedColor; }

   virtual bool Initialize(double aSimTime, WsfScriptContext* aParentContextPtr);

   WsfPlatform* GetOwningPlatform() const;

   WsfScriptProcessor* GetOwningProcessor() const;

   WsfAdvancedBehaviorTree* GetOwningTree() const;

   WsfAdvancedBehaviorTreeNode* GetParent() const { return mParentPtr; }

   const bool PreconditionsMet() const;

   virtual const double PreconditionValue() const { return 0.0; }

   bool ProcessInput(UtInput& aInput) override;

   virtual bool ProcessMessage(double aSimTime, const WsfMessage& aMessage);

   virtual void RegisterInput(UtInput& aInput) {}

   static void Reset() { mNextUniqueId = 0; }

   virtual void ResetPreconditionVars() {}

   void SetFilePath(const std::string& aPath);

   void SetHasParent(const bool aValue);

   void SetParent(WsfAdvancedBehaviorTreeNode* aNodePtr) { mParentPtr = aNodePtr; }

   void SetTooltip(const std::string& aText, const bool aSendEvent = false);

   void SetPreconditionTooltip(const std::string& aText, const bool aSendEvent = false);

   void SetExecuteTooltip(const std::string& aText, const bool aSendEvent = false);

   virtual void SetTree(WsfAdvancedBehaviorTree* aTreePtr){};

   virtual BT::ReturnStatus Tick();

   virtual BT::ReturnStatus TickFunction() { return BT::cIDLE; }

   virtual void TurnOff(){};

   virtual void TurnOn(){};
 
   bool ExecutedLastTick() const { return mExecutedLastTick; }

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

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

   void SetIsTreeRootNode(const bool aState) { mIsTreeRootNode = aState; }

   bool GetIsTreeRootNode() const { return mIsTreeRootNode; }
 
   WsfScriptStateMachine* ChildStateMachine() { return mFiniteStateMachinePtr; }

   WsfAdvancedBehaviorTreeNode* GetTopRootNode();

   UtScript* GetExecuteScript() { return mExecuteScriptPtr; }
 
   void SetInitScript(UtScript* aScriptPtr);
 
protected:
   bool RegisterExternVariable(const std::string& aVariableType, const std::string& aVariableName);

   UtScriptContext* GetScriptAccessibleContext() const override;

   void SetFileInfo(const std::string& aPath, const time_t& aModTime);

   void SetNodeStatus(const BT::ReturnStatus aStatus);
 
   //* Unique integer id of this node
   unsigned int mId{0};
 
   //* Scenario of this node
   const WsfScenario& mScenario;
 
   //* Blackboard for writing and reading script variables
   std::shared_ptr<WsfAttributeContainer> mBlackboard;
 
   //* Pointer to the script context of this node
   WsfScriptContext* mContextPtr{nullptr};
 
   //* Pointer to the script message handler for this node
   WsfScriptMessageHandler* mMessageHandlerPtr{nullptr};
 
   //* Pointer to the parent node of this node
   WsfAdvancedBehaviorTreeNode* mParentPtr{nullptr};
 
   //* Pointer to the tree that parents this node
   WsfAdvancedBehaviorTree* mParentTreePtr{nullptr};
 
   //* Pointer to the finite state machine for this node.
   WsfScriptStateMachine* mFiniteStateMachinePtr{nullptr};
 
   //* Integer representing the current state the finite state machine is in
   int mStateIndex{0};
 
   //* Timestamp representing the last time the script file this node was declared in was modified
   time_t mFileLastModTime;
 
   //* True if debugging is turned on for this node, false otherwise
   bool mDebug{false};
 
   //* True if this node is initialized, false otherwise
   bool mInitialized{false};
 
   //* True if this node is turned on, false otherwise
   bool mTurnedOn{true};
 
   //* Consider this node as another tree?
   bool mIsTreeRootNode{false};
 
   //* True if this node has a parent, false otherwise
   bool mHasParent{false};
 
   //* True if the node ran the execute block last tick.  This is used for on_new_failure and on_new_execute.
   bool mExecutedLastTick{false};
 
   //* True if the node is in its precondition block, false otherwise.  Used to determine which tooltip from script funcs.
   mutable bool mInPrecondition{false};
 
   //* True if the precondition has run for the node this tick, false otherwise.
   mutable bool mPreconditionRan{false};
 
   //* True if the node's precondition has been met(>0.0), false otherwise.  Used in determining whether or not to tick a node
   //* when it's precondition has been skipped for selectors, selectors with memory, and parallel composite nodes.
   mutable bool mPreconditionMet{false};
 
   //* ReturnStatus of the node
   BT::ReturnStatus mReturnStatus{BT::cIDLE};
 
   //* Full file path to the script file this node was declared in
   std::string mFullPathFileName{""};
 
   //* Name of the node
   std::string mName{""};
 
   //* Description of the node
   std::string mDescription{""};
 
   //* Tooltip text for the precondition script block
   std::string mPreconditionTooltip{""};
 
   //* Tooltip text fsor the execute script block
   std::string mExecuteTooltip{""};
 
   //* Time representing when the tooltip text was set
   double mPreconditionTooltipTimestamp{-1.0};
 
   //* Time representing when the tooltip text was set
   double mExecuteTooltipTimestamp{-1.0};
 
   //* Pointer to the initialization script for this node
   UtScript* mOnInitScriptPtr{nullptr};
 
   //* Pointer to a new execute script
   UtScript* mNewExecuteScriptPtr{nullptr};
 
   //* Pointer to a new fail script
   UtScript* mNewFailScriptPtr{nullptr};
 
   //* Pointer to the precondition script of this node
   UtScript* mPreconditionScriptPtr{nullptr};
 
   //* Pointer to the execute script for this node
   UtScript* mExecuteScriptPtr{nullptr};
 
   //* The color to set Platform History trace lines
   UtColor mColor;
 
   //* True if the color was defined through user input, false otherwise
   bool mHasDefinedColor;
 
private:
   //* Counter for unique node ids
   static unsigned int mNextUniqueId;
};
 
class WsfAdvancedBehaviorTreeNodeTypes : public WsfObjectTypeList<WsfAdvancedBehaviorTreeNode>
{
public:
   WsfAdvancedBehaviorTreeNodeTypes(WsfScenario& aScenario);

   LoadResult LoadType(UtInput& aInput) override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeLeafNode : public WsfAdvancedBehaviorTreeNode
{
public:
   WsfAdvancedBehaviorTreeLeafNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeLeafNode(const WsfAdvancedBehaviorTreeLeafNode& aSrc);
   WsfAdvancedBehaviorTreeLeafNode& operator=(const WsfAdvancedBehaviorTreeLeafNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeLeafNode* Clone() const override;

   const int GetDepth() const override { return 0; }

   void Halt(const std::string& aReason) override;

   const double PreconditionValue() const override;

   bool ProcessInput(UtInput& aInput) override;

   void RegisterInput(UtInput& aInput) override;

   void TurnOff() override;

   void TurnOn() override;

   void ResetPreconditionVars() override;
 
protected:
   void SetTree(WsfAdvancedBehaviorTree* aTreePtr) override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeActionNode : public WsfAdvancedBehaviorTreeLeafNode
{
public:
   explicit WsfAdvancedBehaviorTreeActionNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeActionNode& operator=(const WsfAdvancedBehaviorTreeActionNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeActionNode* Clone() const override;

   void Halt(const std::string& aReason) override;

   void SetTree(WsfAdvancedBehaviorTree* aTreePtr) override;

   BT::ReturnStatus Tick() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeConditionNode : public WsfAdvancedBehaviorTreeLeafNode
{
public:
   explicit WsfAdvancedBehaviorTreeConditionNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeConditionNode& operator=(const WsfAdvancedBehaviorTreeConditionNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeConditionNode* Clone() const override;

   void Halt(const std::string& aReason) override;

   BT::ReturnStatus Tick() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeCompositeNode : public WsfAdvancedBehaviorTreeNode
{
public:
   WsfAdvancedBehaviorTreeCompositeNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeCompositeNode(const WsfAdvancedBehaviorTreeCompositeNode& aSrc);
   ~WsfAdvancedBehaviorTreeCompositeNode() override = default;
   WsfAdvancedBehaviorTreeCompositeNode& operator=(const WsfAdvancedBehaviorTreeCompositeNode&) = delete;

   WsfAdvancedBehaviorTreeCompositeNode* Clone() const override;

   void AddChild(std::shared_ptr<WsfAdvancedBehaviorTreeNode> aChildPtr) override;

   void AddTree(ut::CloneablePtr<WsfAdvancedBehaviorTree>& aTreePtr) override;

   std::vector<std::shared_ptr<WsfAdvancedBehaviorTreeNode>>& GetChildren() override { return mChildren; }

   std::map<size_t, ut::CloneablePtr<WsfAdvancedBehaviorTree>>& GetTrees() override { return mTrees; }

   void OutputTreeStructures(const double aSimTime) override;

   void OutputTreeStates(const double aSimTime) override;

   const int GetDepth() const override;

   void Halt(const std::string& aReason) override;

   const bool HasChildrenContainer() const override { return true; };

   bool Initialize(double aSimTime, WsfScriptContext* aParentContextPtr) override;

   const double PreconditionValue() const override;

   void SetTree(WsfAdvancedBehaviorTree* aTreePtr) override;

   void TurnOff() override;

   void TurnOn() override;

   void ResetPreconditionVars() override;
 
protected:
   const bool AreChildrenRunning() const;

   const unsigned int GetLastEnabledChild() const;

   const unsigned int GetNumEnabledChildren() const;

   void HaltChildren(unsigned int aIndex, const std::string& aReason) override;

   void HaltRunning(const std::string& aReason);
 
   //* List of children nodes
   std::vector<std::shared_ptr<WsfAdvancedBehaviorTreeNode>> mChildren;
 
   //* Map of indices to trees, where the index is the slot of the root node in the children.
   std::map<size_t, ut::CloneablePtr<WsfAdvancedBehaviorTree>> mTrees;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeDecoratorNode : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeDecoratorNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeDecoratorNode& operator=(const WsfAdvancedBehaviorTreeDecoratorNode& aRhs) = delete;

   void AddChild(std::shared_ptr<WsfAdvancedBehaviorTreeNode> aChildPtr) override;

   void AddTree(ut::CloneablePtr<WsfAdvancedBehaviorTree>& aTreePtr) override;

   void OutputTreeStructures(const double aSimTime) override;

   void OutputTreeStates(const double aSimTime) override;

   WsfAdvancedBehaviorTreeDecoratorNode* Clone() const override;

   BT::ReturnStatus TickFunction() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeInverterNode : public WsfAdvancedBehaviorTreeDecoratorNode
{
public:
   explicit WsfAdvancedBehaviorTreeInverterNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeInverterNode& operator=(const WsfAdvancedBehaviorTreeInverterNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeInverterNode* Clone() const override;

   BT::ReturnStatus TickFunction() override;
 
private:
   BT::ReturnStatus Convert(const BT::ReturnStatus aStatus);
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeSucceederNode : public WsfAdvancedBehaviorTreeDecoratorNode
{
public:
   explicit WsfAdvancedBehaviorTreeSucceederNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeSucceederNode& operator=(const WsfAdvancedBehaviorTreeSucceederNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeSucceederNode* Clone() const override;

   BT::ReturnStatus TickFunction() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeNegatorNode : public WsfAdvancedBehaviorTreeDecoratorNode
{
public:
   explicit WsfAdvancedBehaviorTreeNegatorNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeNegatorNode& operator=(const WsfAdvancedBehaviorTreeNegatorNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeNegatorNode* Clone() const override;

   const double PreconditionValue() const override { return 0.0; }

   BT::ReturnStatus TickFunction() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeRepeaterNode : public WsfAdvancedBehaviorTreeDecoratorNode
{
public:
   enum RunType
   {
      Repeat,
      ForTime,
      UntilDone
   };
 
   explicit WsfAdvancedBehaviorTreeRepeaterNode(const WsfScenario& aScenario);
   WsfAdvancedBehaviorTreeRepeaterNode& operator=(const WsfAdvancedBehaviorTreeRepeaterNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeRepeaterNode* Clone() const override;

   int& GetRepeats() { return mRepeats; }

   double& GetRunDuration() { return mRunDuration; }

   RunType& GetRunType() { return mRunType; }

   void SetRepeats(const int aRepeatCount);

   void SetRunType(const RunType aRunType);

   BT::ReturnStatus TickFunction() override;
 
protected:
   //* How many times to repeat this node
   int mRepeats;
 
   //* Number of repeats left before defaulting to failure
   int mRepeatsLeft;
 
   //* How long to run this node before defaulting to failure
   double mRunDuration;
 
   //* Time representing when the node started running (used for checking time)
   double mRunStartTime;
 
   //* Run type of this node (Repeater Decorator)
   RunType mRunType;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeParallelNode : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeParallelNode(const WsfScenario& aScenario);
   explicit WsfAdvancedBehaviorTreeParallelNode(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode,
                                                BT::SuccessPolicy  aSuccessPolicy = BT::cSUCCEED_ON_ONE,
                                                const unsigned int aThreshold     = 0);
   WsfAdvancedBehaviorTreeParallelNode& operator=(const WsfAdvancedBehaviorTreeParallelNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeParallelNode* Clone() const override;

   void Halt(const std::string& aReason) override;

   const double PreconditionValue() const override;

   bool ProcessInput(UtInput& aInput) override;

   BT::ReturnStatus TickFunction() override;
 
private:
   BT::SuccessPolicy GetSuccessPolicy() const { return mPolicy; }

   const unsigned int& GetThreshold() const { return mThreshold; }

   void SetSuccessPolicy(const BT::SuccessPolicy aPolicy);

   void SetThreshold(const unsigned int aThreshold);
 
   //* Number of children that have failed
   unsigned int mNumChildrenFailure = 0;
 
   //* Number of children that have succeeded
   unsigned int mNumChildrenSuccess = 0;
 
   //* Policy for handling when a parallel node should return success
   BT::SuccessPolicy mPolicy = BT::cTHRESHOLD;
 
   //* Threshold needed for this node to succeed
   unsigned int mThreshold = 1;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeSelectorNode : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeSelectorNode(const WsfScenario& aScenario);
   explicit WsfAdvancedBehaviorTreeSelectorNode(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode);
   WsfAdvancedBehaviorTreeSelectorNode& operator=(const WsfAdvancedBehaviorTreeSelectorNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeSelectorNode* Clone() const override;

   const double PreconditionValue() const override;

   BT::ReturnStatus TickFunction() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeSelectorNodeWithMemory : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeSelectorNodeWithMemory(const WsfScenario& aScenario, BT::ResetPolicy aResetPolicy);
   explicit WsfAdvancedBehaviorTreeSelectorNodeWithMemory(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode,
                                                          BT::ResetPolicy                             aResetPolicy);
   WsfAdvancedBehaviorTreeSelectorNodeWithMemory& operator=(const WsfAdvancedBehaviorTreeSelectorNodeWithMemory& aRhs) = delete;

   WsfAdvancedBehaviorTreeSelectorNodeWithMemory* Clone() const override;

   void Halt(const std::string& aReason) override;

   const double PreconditionValue() const override;

   BT::ReturnStatus TickFunction() override;
 
private:
   //* Current child we are skipping to
   unsigned int mCurrentChildIndex;
 
   //* Reset policy for this Sequence
   BT::ResetPolicy mResetPolicy;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeSequenceNode : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeSequenceNode(const WsfScenario& aScenario);
   explicit WsfAdvancedBehaviorTreeSequenceNode(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode);
   WsfAdvancedBehaviorTreeSequenceNode& operator=(const WsfAdvancedBehaviorTreeSequenceNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeSequenceNode* Clone() const override;

   BT::ReturnStatus TickFunction() override;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeSequenceNodeWithMemory : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeSequenceNodeWithMemory(const WsfScenario& aScenario, BT::ResetPolicy aResetPolicy);
   explicit WsfAdvancedBehaviorTreeSequenceNodeWithMemory(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode,
                                                          BT::ResetPolicy                             aResetPolicy);
   WsfAdvancedBehaviorTreeSequenceNodeWithMemory& operator=(const WsfAdvancedBehaviorTreeSequenceNodeWithMemory& aRhs) = delete;

   WsfAdvancedBehaviorTreeSequenceNodeWithMemory* Clone() const override;

   void Halt(const std::string& aReason) override;

   BT::ReturnStatus TickFunction() override;
 
private:
   //* Current child we are skipping to
   unsigned int mCurrentChildIndex;
 
   //* Reset policy for this Sequence
   BT::ResetPolicy mResetPolicy;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreePrioritySelectorNode : public WsfAdvancedBehaviorTreeSelectorNode
{
public:
   explicit WsfAdvancedBehaviorTreePrioritySelectorNode(const WsfScenario& aScenario);
   explicit WsfAdvancedBehaviorTreePrioritySelectorNode(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode);
   WsfAdvancedBehaviorTreePrioritySelectorNode& operator=(const WsfAdvancedBehaviorTreePrioritySelectorNode& aRhs) = delete;

   WsfAdvancedBehaviorTreePrioritySelectorNode* Clone() const override;

   const double PreconditionValue() const override;

   BT::ReturnStatus TickFunction() override;
 
private:
   WsfAdvancedBehaviorTreeNode* GetCurrentSelection() const { return mCurrentSelectionPtr; }

   void SetCurrentSelection(WsfAdvancedBehaviorTreeNode* aNodePtr) { mCurrentSelectionPtr = aNodePtr; }
 
   //* Pointer to the currently selected node.  If a node is selected, the priority selector won't check weights on tick.
   mutable WsfAdvancedBehaviorTreeNode* mCurrentSelectionPtr;
};
 
class WSF_EXPORT WsfAdvancedBehaviorTreeWeightedRandomNode : public WsfAdvancedBehaviorTreeCompositeNode
{
public:
   explicit WsfAdvancedBehaviorTreeWeightedRandomNode(const WsfScenario& aScenario);
   explicit WsfAdvancedBehaviorTreeWeightedRandomNode(const WsfAdvancedBehaviorTreeCompositeNode& aCompositeNode);
   WsfAdvancedBehaviorTreeWeightedRandomNode& operator=(const WsfAdvancedBehaviorTreeWeightedRandomNode& aRhs) = delete;

   WsfAdvancedBehaviorTreeWeightedRandomNode* Clone() const override;

   const double PreconditionValue() const override;

   BT::ReturnStatus TickFunction() override;
 
private:
   const std::pair<double, WsfAdvancedBehaviorTreeNode*> GetRandomNode() const;
 
   //* Pointer to the weighted random node that was chosen on draw during the PreconditionValue() call
   mutable WsfAdvancedBehaviorTreeNode* mCurrentSelectionPtr;
};
#endif