BehaviourTreeContext.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <Atoms/BehaviourTree/Behaviour.h>
#include <Atoms/BehaviourTree/Blackboard.h>
#include <Atoms/BehaviourTree/BlackboardValue.h>
#include <Atoms/AgentGroup.h>
#include <Atoms/Agent.h>
#include <vector>
#include <deque>
 
namespace Atoms
{
    class BehaviourTree;
 
    class ATOMS_EXPORT BehaviourTreeContext
    {
    public:
 
        struct ChildState
        {
            unsigned short index;
            unsigned short state;
        };
 
        struct BehaviourStackState
        {
            Behaviour::State state;
            unsigned short childIndex;
            unsigned short childState;
        };
 
        class AgentScopeLock
        {
        public:
            AgentScopeLock(Atoms::Agent* ag) : agent(ag) {
                if (agent) { agent->lock(); }
            }
            ~AgentScopeLock()
            {
                if (agent) { agent->unlock(); }
            }
            Atoms::Agent* agent;
        };
 
        const unsigned short nullIndex = 0;
 
        BehaviourTreeContext();
 
        BehaviourTreeContext(BehaviourTree* bt);
 
        ~BehaviourTreeContext();
 
        void setTree(BehaviourTree* bt);
 
        bool start();
 
        bool start(const std::string& name);
 
        bool start(unsigned short index);
 
        void abort(unsigned short index);
 
        bool isRunning() const;
 
        void stop();
 
        Behaviour::Status tick();
 
        void updateParent(Behaviour* behaviour, Behaviour::State& current);
        void dirtyUpdateParent(Behaviour* behaviour, Behaviour::State& current);
 
        template <class T>
        T* allocateMemory() {
            return new T();
        }
 
        template <class T>
        void releaseMemory(T* data) {
            delete data;
        }
 
        std::string behaviourName(unsigned short index) const;
 
        template <class T>
        inline T& getBlackboardValue(BlackboardValue<T>& value);
 
        template <class T>
        inline std::vector<T>& getBlackboardValue(BlackboardValue<std::vector<T>>& value);
 
        template <class T>
        inline bool setBlackboardValue(const BlackboardValue<T>& value);
 
        template <class T>
        inline bool setBlackboardValue(const BlackboardValue<std::vector<T>>& value);
 
        AtomsPtr<AtomsCore::Metadata> getBlackboardValueFromName(const std::string& name) const;
 
        AtomsPtr<AtomsCore::Metadata> getBlackboardValueFromPosition(const BlackboardEntryPosition& position) const;
 
        void cacheMetadata(Atoms::BlackboardEntryPosition& position);
 
        void unCacheMetadata(Atoms::BlackboardEntryPosition& position);
 
        void lock();
 
        void unlock();
 
    public:
 
        BlackboardInstance blackboardInstance;
 
        BehaviourTree* tree;
 
        AgentGroup* agentGroup;
 
        Agent* agent;
 
        std::mutex* mutex;
 
        std::deque<BehaviourStackState> m_activeBehaviours;
 
        std::vector<Behaviour::State> m_activeStack;
 
        std::vector<BehaviourStackState> m_aborted;
 
        std::vector<BehaviourStackState> m_started;
 
        std::vector<unsigned short> m_successBehaviours;
        std::vector<unsigned short> m_failureBehaviours;
 
        unsigned short tickCount;
 
        double tickTime;
 
        unsigned int seed;
 
        bool debug;
 
        bool isLocked;
    };
 
 
    template <class T>
    inline T& BehaviourTreeContext::getBlackboardValue(BlackboardValue<T>& value)
    {
        if (value.position.valueIndex == -1)
        {
            return value.value;
        }
        
        auto* sourceboard = &blackboardInstance;
        if (value.position.parentIndex > 0)
        {
            for (short i = 0; i < value.position.parentIndex; ++i)
            {
                if (!sourceboard)
                {
                    break;
                }
 
                sourceboard = sourceboard->parent;
            }
        }
 
        // Not value found on the blackboard
        if (!sourceboard || sourceboard->size() <= value.position.valueIndex)
        {
            return value.value;
        }
 
        auto& entry = sourceboard->blackboard->entry(value.position.valueIndex);
        auto& instanceEntry = sourceboard->entry(value.position.valueIndex);
        if (entry.flags != Atoms::BlackboardEntry::Flags::LinkMetadata)
        {
            if (instanceEntry && instanceEntry->typeId() == AtomsCore::MetadataImpl<T>::staticTypeId())
            {
                auto metaPtr = static_cast<AtomsCore::MetadataImpl<T>*>(instanceEntry.get());
                return metaPtr->get();
            }
            else
            {
                return value.value;
            }
        }
                    
        if (!agent)
            return value.value;
 
        auto agentMeta = agent->metadata().getTypedEntry<AtomsCore::MetadataImpl<T>>(entry.name);
        if (!agentMeta)
            return value.value;
 
        return agentMeta->get();
    }
 
    template <>
    inline AtomsPtr<AtomsCore::Metadata>& BehaviourTreeContext::getBlackboardValue<AtomsPtr<AtomsCore::Metadata>>(BlackboardMetadataValue& value)
    {
        if (value.position.valueIndex == -1)
        {
            return value.value;
        }
 
        auto* sourceboard = &blackboardInstance;
        if (value.position.parentIndex > 0)
        {
            for (short i = 0; i < value.position.parentIndex; ++i)
            {
                if (!sourceboard)
                {
                    break;
                }
 
                sourceboard = sourceboard->parent;
            }
        }
 
        // Not value found on the blackboard
        if (!sourceboard || sourceboard->size() <= value.position.valueIndex)
        {
            return value.value;
        }
 
        auto& entry = sourceboard->blackboard->entry(value.position.valueIndex);
        auto& instanceEntry = sourceboard->entry(value.position.valueIndex);
        if (entry.flags != Atoms::BlackboardEntry::Flags::LinkMetadata)
        {
            if (instanceEntry)
            {
                return instanceEntry;
            }
            else
            {
                return value.value;
            }
        }
 
        if (!agent)
            return value.value;
 
        auto agentMeta = agent->metadata().data().find(entry.name);
        if (agentMeta == agent->metadata().data().end())
            return value.value;
 
        return agentMeta->second;
    }
 
    template <class T>
    inline std::vector<T>& BehaviourTreeContext::getBlackboardValue(BlackboardValue<std::vector<T>>& value)
    {
        if (value.position.valueIndex == -1)
        {
            return value.value;
        }
 
        auto* sourceboard = &blackboardInstance;
        if (value.position.parentIndex > 0)
        {
            for (short i = 0; i < value.position.parentIndex; ++i)
            {
                if (!sourceboard)
                {
                    break;
                }
 
                sourceboard = sourceboard->parent;
            }
        }
 
        // Not value found on the blackboard
        if (!sourceboard || sourceboard->size() <= value.position.valueIndex)
        {
            return value.value;
        }
 
        auto& entry = sourceboard->blackboard->entry(value.position.valueIndex);
        auto& instanceEntry = sourceboard->entry(value.position.valueIndex);
        if (entry.flags != Atoms::BlackboardEntry::Flags::LinkMetadata)
        {
            if (instanceEntry && instanceEntry->typeId() == AtomsCore::TypedArrayMetadata<T>::staticTypeId())
            {
                auto metaPtr = static_cast<AtomsCore::TypedArrayMetadata<T>*>(instanceEntry.get());
                return metaPtr->get();
            }
            else
            {
                return value.value;
            }
        }
 
        if (!agent)
            return value.value;
 
        auto agentMeta = agent->metadata().getTypedEntry<AtomsCore::TypedArrayMetadata<T>>(entry.name);
        if (!agentMeta)
            return value.value;
 
        return agentMeta->get();
    }
 
    template <class T>
    inline bool BehaviourTreeContext::setBlackboardValue(const BlackboardValue<T>& value)
    {
        if (value.position.valueIndex == -1)
        {
            return false;
        }
 
        auto* sourceboard = &blackboardInstance;
        if (value.position.parentIndex > 0)
        {
            for (short i = 0; i < value.position.parentIndex; ++i)
            {
                if (!sourceboard)
                {
                    break;
                }
 
                sourceboard = sourceboard->parent;
            }
        }
 
        // Not value found on the blackboard
        if (!sourceboard || sourceboard->size() <= value.position.valueIndex)
        {
            return false;
        }
 
        auto& entry = sourceboard->blackboard->entry(value.position.valueIndex);
        auto& instanceEntry = sourceboard->entry(value.position.valueIndex);
        if (entry.flags != Atoms::BlackboardEntry::Flags::LinkMetadata)
        {
            if (instanceEntry && instanceEntry->typeId() == AtomsCore::MetadataImpl<T>::staticTypeId())
            {
                static_cast<AtomsCore::MetadataImpl<T>*>(instanceEntry.get())->set(value.value);
                return true;
            }
            return false;
        }
 
        if (!agent)
            return false;
 
        auto agentMeta = agent->metadata().getEntry(entry.name);
        if (agentMeta && agentMeta->typeId() == AtomsCore::MetadataImpl<T>::staticTypeId())
        {
            static_cast<AtomsCore::MetadataImpl<T>*>(agentMeta.get())->set(value.value);
            return true;
        }
        return false;
    }
 
    template <>
    inline bool BehaviourTreeContext::setBlackboardValue<AtomsPtr<AtomsCore::Metadata>>(const BlackboardMetadataValue& value)
    {
        if (value.position.valueIndex == -1)
        {
            return false;
        }
 
        auto* sourceboard = &blackboardInstance;
        if (value.position.parentIndex > 0)
        {
            for (short i = 0; i < value.position.parentIndex; ++i)
            {
                if (!sourceboard)
                {
                    break;
                }
 
                sourceboard = sourceboard->parent;
            }
        }
 
        // Not value found on the blackboard
        if (!sourceboard || sourceboard->size() <= value.position.valueIndex)
        {
            return false;
        }
 
        auto& entry = sourceboard->blackboard->entry(value.position.valueIndex);
        auto& instanceEntry = sourceboard->entry(value.position.valueIndex);
        if (entry.flags != Atoms::BlackboardEntry::Flags::LinkMetadata)
        {
            if (instanceEntry && instanceEntry->typeId() == value.value->typeId())
            {
                instanceEntry->copy(value.value.get());
            }
            else
            {
                instanceEntry = value.value->clone();
            }
            return true;
        }
 
        if (!agent)
            return false;
 
        auto agentMeta = agent->metadata().getEntry(entry.name);
        if (agentMeta && agentMeta->typeId() == value.value->typeId())
        {
            agentMeta->copy(value.value.get());
            return true;
        }
        return false;
    }
 
    template <class T>
    inline bool BehaviourTreeContext::setBlackboardValue(const BlackboardValue<std::vector<T>>& value)
    {
        if (value.position.valueIndex == -1)
        {
            return false;
        }
 
        auto* sourceboard = &blackboardInstance;
        if (value.position.parentIndex > 0)
        {
            for (short i = 0; i < value.position.parentIndex; ++i)
            {
                if (!sourceboard)
                {
                    break;
                }
 
                sourceboard = sourceboard->parent;
            }
        }
 
        // Not value found on the blackboard
        if (!sourceboard || sourceboard->size() <= value.position.valueIndex)
        {
            return false;
        }
 
        auto& entry = sourceboard->blackboard->entry(value.position.valueIndex);
        auto& instanceEntry = sourceboard->entry(value.position.valueIndex);
        if (entry.flags != Atoms::BlackboardEntry::Flags::LinkMetadata)
        {
            if (instanceEntry && instanceEntry->typeId() == AtomsCore::TypedArrayMetadata<T>::staticTypeId())
            {
                static_cast<AtomsCore::TypedArrayMetadata<T>*>(instanceEntry.get())->set(value.value);
                return true;
            }
            return false;
        }
 
        if (!agent)
            return false;
 
        auto agentMeta = agent->metadata().getEntry(entry.name);
        if (agentMeta && agentMeta->typeId() == AtomsCore::TypedArrayMetadata<T>::staticTypeId())
        {
            static_cast<AtomsCore::TypedArrayMetadata<T>*>(agentMeta.get())->set(value.value);
            return true;
        }
        return false;
    }
}