BehaviourModuleAttributeCache.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/GlobalNames.h>
#include <AtomsCore/Metadata/All.h>
#include <AtomsUtils/AtomsMath.h>
#include <Atoms/Agent.h>
#include <vector>
#include <functional>
#include <AtomsJIT/AtomsScriptLang.h>
#include <Atoms/AtomsScriptUtils.h>
#include <ToolchefsSTL/String.h>
 
namespace Atoms
{
 
    template<typename T>
    struct AttributeCacheScriptType
    {
        typedef T Type;
    };
 
    template<>
    struct AttributeCacheScriptType<std::string>
    {
        typedef ToolchefsSTL::String Type;
    };
 
 
    template <typename T>
    class BehaviourModuleAttributeCache
    {
    public:
 
        typedef typename AttributeCacheScriptType<T>::Type InternalType;
 
        BehaviourModuleAttributeCache<T>():m_agentGroupWrapper(nullptr)
        {
            m_mode = -1;
            m_seed = 0;
            m_minValue = AtomsMath::numeric_limits<T>::min();
            m_maxValue = AtomsMath::numeric_limits<T>::max();
            m_listValue.clear();
            m_agentGroup = nullptr;
        }
 
        void fillOverrideList(const AtomsCore::MapMetadata& attributes, const std::string& attributeName)
        {
            auto listPtr = attributes.getTypedEntry<AtomsCore::TypedArrayMetadata<T>>(attributeName + ATOMS_BEHAVIOUR_OVERRIDE_LIST_SUFFIX);
            if (listPtr)
            {
                m_listValue.clear();
                for (auto v : listPtr->get())
                    m_listValue.push_back(v);
            }
        }
 
        BehaviourModuleAttributeCache<T>(
            const AtomsCore::MapMetadata& attributes, const std::string& attributeName, 
            const std::string& behaviourModuleName, class AgentGroup* agentGroup):
            m_agentGroupWrapper(agentGroup)
        {
            m_mode = -1;
            m_seed = 0;
            m_minValue = AtomsMath::numeric_limits<T>::min();
            m_maxValue = AtomsMath::numeric_limits<T>::max();
            m_listValue.clear();
            m_agentGroup = agentGroup;
 
            m_metadataName = behaviourModuleName + "@" + attributeName;
 
            auto attrPtr = attributes.getTypedEntry<AtomsCore::MetadataImpl<T>>(attributeName);
            if (!attrPtr)
                return;
 
            m_defaultValue = attrPtr->get();
            m_overrideMap = attributes.getTypedEntry<AtomsCore::MapMetadata>(attributeName + "_override");
 
            auto modePtr = attributes.getTypedEntry<AtomsCore::MetadataImpl<int>>(attributeName + ATOMS_BEHAVIOUR_OVERRIDE_RANDOM_MODE_SUFFIX);
            if (modePtr)
                m_mode = modePtr->value();
 
            auto seedPtr = attributes.getTypedEntry<AtomsCore::MetadataImpl<int>>(attributeName + ATOMS_BEHAVIOUR_OVERRIDE_RANDOM_SEED_SUFFIX);
            if (seedPtr)
                m_seed = seedPtr->value();
 
            auto minValuePtr = attributes.getTypedEntry<AtomsCore::MetadataImpl<T>>(attributeName + ATOMS_BEHAVIOUR_OVERRIDE_MIN_VALUE_SUFFIX);
            if (minValuePtr)
                m_minValue = minValuePtr->value();
 
            auto maxValuePtr = attributes.getTypedEntry<AtomsCore::MetadataImpl<T>>(attributeName + ATOMS_BEHAVIOUR_OVERRIDE_MAX_VALUE_SUFFIX);
            if (maxValuePtr)
                m_maxValue = maxValuePtr->value();
            /*
            auto listPtr = attributes.getTypedEntry<AtomsCore::TypedArrayMetadata<T>>(attributeName + ATOMS_BEHAVIOUR_OVERRIDE_LIST_SUFFIX);
            if (listPtr)
            {
                m_listValue.clear();
                for (auto v : listPtr->get())
                    m_listValue.push_back(v);
            }
            */
            fillOverrideList(attributes, attributeName);
 
            auto expressionMetaPtr = attributes.getTypedEntry<AtomsCore::StringMetadata>(attributeName + "_expression");
            if (m_mode == 3 && expressionMetaPtr && !expressionMetaPtr->get().empty())
            {
                AtomsCore::MurmurHash3 hasher;
                hasher.append(expressionMetaPtr->get());
                auto baseType = AtomsCore::MetadataImpl<T>::staticBaseTypeStr();
                if (baseType == AtomsCore::StringMetadata::staticBaseTypeStr())
                {
                    baseType = "String";
                }
                std::string functionName = "__expression_" + behaviourModuleName + "__" + attributeName + "_" + hasher.string();
                std::string expressionCode;
                expressionCode += "#include <Atoms/AtomsScriptUtils.h>\n";
                expressionCode += "using namespace AtomsScriptUtils;\n";
                expressionCode += "using namespace AtomsMath;\n";
                expressionCode += "using namespace AtomsUtils;\n";
                expressionCode += "using namespace ToolchefsSTL;\n";
                expressionCode += "void " + functionName + "(";
                expressionCode += baseType + "& output";
                expressionCode += ", const AgentWrapper& agent, const AgentGroupWrapper& agentGroup";
                expressionCode += ", const "+ baseType +"& defaultValue";
                expressionCode += "){\n";
                expressionCode += expressionMetaPtr->get();
                expressionCode += "\n }";
 
                auto& compiler = Atoms::AtomsScriptLang::instance();
                if (!compiler.addCode(functionName, expressionCode))
                {
                    AtomsUtils::Logger::error() << "Unable to compile expression for attribute " << attributeName << " in module " << behaviourModuleName;
                }
                else
                {
                    m_script = compiler.lookup<void(InternalType&, const AtomsScriptUtils::AgentWrapper&, const AtomsScriptUtils::AgentGroupWrapper&, const InternalType&)>(functionName, functionName);
                }
            }
        }
 
        const T getAttributeValue(const int groupId, const std::string &groupIdStr, class Agent* agent) const
        {
            if (agent)
            {
                const auto& agentMetadata = agent->metadata();
                auto agentDataPtr = agentMetadata.getTypedEntry<AtomsCore::MetadataImpl<T>>(m_metadataName);
                if (agentDataPtr)
                {
                    return agentDataPtr->value();
                }
            }
 
            if (m_overrideMap)
            {
                auto dataPtr = m_overrideMap->getTypedEntry<AtomsCore::MetadataImpl<T>>(groupIdStr);
                if (dataPtr)
                    return dataPtr->value();
            }
 
            if (m_mode == -1)
                return m_defaultValue;
 
            AtomsCore::Rand48 random;
            random.init(m_seed + groupId);
 
            switch (m_mode)
            {
            case 0:
            {
                return m_defaultValue;
            }
            case 1:
            {
                return AtomsMath::RandomValue<T>::value(random, m_minValue, m_maxValue);
            }
            case 2:
            {
                if (m_listValue.size() > 0)
                    return m_listValue[random.nexti() % m_listValue.size()];
            }
            case 3:
                if (m_script)
                {
                    T outValue = m_defaultValue;
                    AtomsScriptUtils::AgentWrapper wrapper(agent);
                    m_script(outValue, wrapper, m_agentGroupWrapper, m_defaultValue);
                    return outValue;
                }
                return m_defaultValue;
            }
 
            return m_defaultValue;
        }
 
        inline const bool hasOverride(const std::string& groupId)
        {
            return m_overrideMap ? m_overrideMap->hasKey(groupId) : false;
        }
 
        inline const T& defaultValue() const { return m_defaultValue; }
 
    private:
        std::vector<T> m_listValue;
        std::string m_metadataName;
 
        
 
        std::function<void(InternalType&, const AtomsScriptUtils::AgentWrapper&, const AtomsScriptUtils::AgentGroupWrapper&, const InternalType&)> m_script;
 
        T m_defaultValue;
 
        int m_mode;
        int m_seed;
        T m_minValue;
        T m_maxValue;
 
        AtomsPtr<const AtomsCore::MapMetadata> m_overrideMap;
 
        class AgentGroup* m_agentGroup;
        AtomsScriptUtils::AgentGroupWrapper m_agentGroupWrapper;
    };
 
    template<> ATOMS_EXPORT const std::string BehaviourModuleAttributeCache<std::string>::getAttributeValue(const int groupId, const std::string& groupIdStr, class Agent* agent) const;
    template<> ATOMS_EXPORT void BehaviourModuleAttributeCache<bool>::fillOverrideList(const AtomsCore::MapMetadata& attributes, const std::string& attributeName);
 
}