behavior_state_machine_ops.h

#pragma once
 
#include "pixelbullet/scene/behavior_state_machine_types.h"
 
#include <algorithm>
#include <optional>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
namespace pixelbullet
{
inline void NormalizeBehaviorBindingSlots(std::vector<std::string>& binding_slots)
{
    std::vector<std::string> normalized;
    normalized.reserve(binding_slots.size());
    for (std::string& slot_name : binding_slots)
    {
        if (slot_name.empty())
        {
            continue;
        }
 
        if (std::find(normalized.begin(), normalized.end(), slot_name) == normalized.end())
        {
            normalized.push_back(std::move(slot_name));
        }
    }
 
    binding_slots = std::move(normalized);
}
 
inline void NormalizeBehaviorStringParameters(std::vector<BehaviorStringParameterDeclaration>& parameters)
{
    std::vector<BehaviorStringParameterDeclaration> normalized;
    normalized.reserve(parameters.size());
    for (BehaviorStringParameterDeclaration& parameter : parameters)
    {
        if (parameter.name.empty())
        {
            continue;
        }
 
        const auto existing = std::find_if(normalized.begin(), normalized.end(),
                                           [&](const BehaviorStringParameterDeclaration& candidate)
                                           { return candidate.name == parameter.name; });
        if (existing == normalized.end())
        {
            normalized.push_back(std::move(parameter));
        }
        else
        {
            *existing = std::move(parameter);
        }
    }
 
    parameters = std::move(normalized);
}
 
inline void NormalizeBehaviorStringParameterOverrides(std::vector<BehaviorStringParameterValue>& overrides)
{
    std::vector<BehaviorStringParameterValue> normalized;
    normalized.reserve(overrides.size());
    for (BehaviorStringParameterValue& override_value : overrides)
    {
        if (override_value.name.empty())
        {
            continue;
        }
 
        const auto existing = std::find_if(normalized.begin(), normalized.end(),
                                           [&](const BehaviorStringParameterValue& candidate)
                                           { return candidate.name == override_value.name; });
        if (existing == normalized.end())
        {
            normalized.push_back(std::move(override_value));
        }
        else
        {
            *existing = std::move(override_value);
        }
    }
 
    overrides = std::move(normalized);
}
 
inline void NormalizeBehaviorBindings(std::vector<BehaviorBinding>& bindings)
{
    std::vector<BehaviorBinding> normalized;
    normalized.reserve(bindings.size());
    for (BehaviorBinding& binding : bindings)
    {
        if (binding.slot_name.empty())
        {
            continue;
        }
 
        const auto existing = std::find_if(normalized.begin(), normalized.end(),
                                           [&](const BehaviorBinding& candidate) { return candidate.slot_name == binding.slot_name; });
        if (existing == normalized.end())
        {
            normalized.push_back(std::move(binding));
        }
        else
        {
            *existing = std::move(binding);
        }
    }
 
    bindings = std::move(normalized);
}
 
inline void NormalizeBehaviorEditorGraphLayout(BehaviorEditorGraphLayout& layout)
{
    std::vector<BehaviorEditorGraphNodeLayout> normalized;
    normalized.reserve(layout.nodes.size());
    for (BehaviorEditorGraphNodeLayout& node : layout.nodes)
    {
        if (node.state_name.empty())
        {
            continue;
        }
 
        const auto existing = std::find_if(normalized.begin(), normalized.end(), [&](const BehaviorEditorGraphNodeLayout& candidate)
                                           { return candidate.state_name == node.state_name; });
        if (existing == normalized.end())
        {
            normalized.push_back(std::move(node));
        }
        else
        {
            *existing = std::move(node);
        }
    }
 
    layout.nodes = std::move(normalized);
}
 
inline void NormalizeBehaviorStateMachineAsset(BehaviorStateMachineAsset& asset)
{
    NormalizeBehaviorStringParameters(asset.string_parameters);
    NormalizeBehaviorBindingSlots(asset.binding_slots);
    if (asset.editor_graph)
    {
        NormalizeBehaviorEditorGraphLayout(*asset.editor_graph);
        if (asset.editor_graph->Empty())
        {
            asset.editor_graph.reset();
        }
    }
    if (asset.initial_state.empty() && !asset.states.empty())
    {
        asset.initial_state = asset.states.front().name;
    }
}
 
[[nodiscard]] inline const BehaviorStringParameterDeclaration*
FindBehaviorStringParameterDeclaration(const BehaviorStateMachineAsset& asset, const std::string_view parameter_name)
{
    const auto it = std::find_if(asset.string_parameters.begin(), asset.string_parameters.end(),
                                 [&](const BehaviorStringParameterDeclaration& parameter) { return parameter.name == parameter_name; });
    return it == asset.string_parameters.end() ? nullptr : &(*it);
}
 
[[nodiscard]] inline BehaviorStringParameterDeclaration* FindBehaviorStringParameterDeclaration(BehaviorStateMachineAsset& asset,
                                                                                                const std::string_view parameter_name)
{
    const auto it = std::find_if(asset.string_parameters.begin(), asset.string_parameters.end(),
                                 [&](const BehaviorStringParameterDeclaration& parameter) { return parameter.name == parameter_name; });
    return it == asset.string_parameters.end() ? nullptr : &(*it);
}
 
[[nodiscard]] inline const BehaviorVariableDeclaration*
FindBehaviorVariableDeclaration(const BehaviorStateMachineAsset& asset, const std::string_view variable_name)
{
    const auto it = std::find_if(asset.variables.begin(), asset.variables.end(),
                                 [&](const BehaviorVariableDeclaration& variable) { return variable.name == variable_name; });
    return it == asset.variables.end() ? nullptr : &(*it);
}
 
[[nodiscard]] inline BehaviorVariableDeclaration* FindBehaviorVariableDeclaration(BehaviorStateMachineAsset& asset,
                                                                                  const std::string_view variable_name)
{
    const auto it = std::find_if(asset.variables.begin(), asset.variables.end(),
                                 [&](const BehaviorVariableDeclaration& variable) { return variable.name == variable_name; });
    return it == asset.variables.end() ? nullptr : &(*it);
}
 
[[nodiscard]] inline std::optional<std::size_t> FindBehaviorStateIndex(const BehaviorStateMachineAsset& asset,
                                                                       const std::string_view state_name)
{
    for (std::size_t index = 0; index < asset.states.size(); ++index)
    {
        if (asset.states[index].name == state_name)
        {
            return index;
        }
    }
 
    return std::nullopt;
}
 
[[nodiscard]] inline const BehaviorState* FindBehaviorState(const BehaviorStateMachineAsset& asset, const std::string_view state_name)
{
    const auto index = FindBehaviorStateIndex(asset, state_name);
    return index ? &asset.states[*index] : nullptr;
}
 
[[nodiscard]] inline BehaviorState* FindBehaviorState(BehaviorStateMachineAsset& asset, const std::string_view state_name)
{
    const auto index = FindBehaviorStateIndex(asset, state_name);
    return index ? &asset.states[*index] : nullptr;
}
 
[[nodiscard]] inline const BehaviorEditorGraphNodeLayout* FindBehaviorEditorGraphNodeLayout(const BehaviorStateMachineAsset& asset,
                                                                                            const std::string_view state_name)
{
    if (!asset.editor_graph)
    {
        return nullptr;
    }
 
    const auto it = std::find_if(asset.editor_graph->nodes.begin(), asset.editor_graph->nodes.end(),
                                 [&](const BehaviorEditorGraphNodeLayout& node) { return node.state_name == state_name; });
    return it == asset.editor_graph->nodes.end() ? nullptr : &(*it);
}
 
[[nodiscard]] inline BehaviorEditorGraphNodeLayout* FindBehaviorEditorGraphNodeLayout(BehaviorStateMachineAsset& asset,
                                                                                      const std::string_view state_name)
{
    if (!asset.editor_graph)
    {
        return nullptr;
    }
 
    const auto it = std::find_if(asset.editor_graph->nodes.begin(), asset.editor_graph->nodes.end(),
                                 [&](const BehaviorEditorGraphNodeLayout& node) { return node.state_name == state_name; });
    return it == asset.editor_graph->nodes.end() ? nullptr : &(*it);
}
 
inline BehaviorEditorGraphNodeLayout& EnsureBehaviorEditorGraphNodeLayout(BehaviorStateMachineAsset& asset, std::string state_name)
{
    if (!asset.editor_graph)
    {
        asset.editor_graph = BehaviorEditorGraphLayout{};
    }
 
    if (BehaviorEditorGraphNodeLayout* existing = FindBehaviorEditorGraphNodeLayout(asset, state_name))
    {
        return *existing;
    }
 
    asset.editor_graph->nodes.push_back(BehaviorEditorGraphNodeLayout{
        .state_name = std::move(state_name),
        .position = glm::vec2(0.0f),
    });
    return asset.editor_graph->nodes.back();
}
 
inline bool RenameBehaviorState(BehaviorStateMachineAsset& asset, const std::string_view old_name, std::string new_name)
{
    BehaviorState* state = FindBehaviorState(asset, old_name);
    if (!state)
    {
        return false;
    }
 
    const std::string previous_name = state->name;
    state->name = std::move(new_name);
 
    if (asset.initial_state == previous_name)
    {
        asset.initial_state = state->name;
    }
 
    for (BehaviorState& candidate : asset.states)
    {
        for (BehaviorTransition& transition : candidate.transitions)
        {
            if (transition.target_state == previous_name)
            {
                transition.target_state = state->name;
            }
        }
    }
 
    if (BehaviorEditorGraphNodeLayout* layout = FindBehaviorEditorGraphNodeLayout(asset, previous_name))
    {
        layout->state_name = state->name;
    }
 
    return true;
}
 
inline bool DeleteBehaviorState(BehaviorStateMachineAsset& asset, const std::string_view state_name)
{
    const auto state_it =
        std::find_if(asset.states.begin(), asset.states.end(), [&](const BehaviorState& state) { return state.name == state_name; });
    if (state_it == asset.states.end())
    {
        return false;
    }
 
    const bool deleted_initial_state = asset.initial_state == state_it->name;
    const std::string deleted_name = state_it->name;
    asset.states.erase(state_it);
 
    for (BehaviorState& state : asset.states)
    {
        std::erase_if(state.transitions, [&](const BehaviorTransition& transition) { return transition.target_state == deleted_name; });
    }
 
    if (asset.editor_graph)
    {
        std::erase_if(asset.editor_graph->nodes,
                      [&](const BehaviorEditorGraphNodeLayout& node) { return node.state_name == deleted_name; });
        if (asset.editor_graph->nodes.empty())
        {
            asset.editor_graph.reset();
        }
    }
 
    if (deleted_initial_state)
    {
        asset.initial_state = asset.states.empty() ? std::string{} : asset.states.front().name;
    }
 
    return true;
}
} // namespace pixelbullet