prefab_behavior_overrides_component.h

#pragma once
 
#include "pixelbullet/scene/behavior_state_machine_asset.h"
#include "pixelbullet/serialization/node.h"
 
#include <algorithm>
#include <vector>
 
namespace pixelbullet
{
struct PrefabBehaviorOverrideEntry
{
    EntityId prefab_entity = EntityId::Invalid();
    std::vector<BehaviorStringParameterValue> string_parameter_overrides;
 
    [[nodiscard]] bool operator==(const PrefabBehaviorOverrideEntry&) const noexcept = default;
};
 
inline void NormalizePrefabBehaviorOverrideEntries(std::vector<PrefabBehaviorOverrideEntry>& overrides)
{
    std::vector<PrefabBehaviorOverrideEntry> normalized;
    normalized.reserve(overrides.size());
    for (PrefabBehaviorOverrideEntry& override_entry : overrides)
    {
        NormalizeBehaviorStringParameterOverrides(override_entry.string_parameter_overrides);
        if (!override_entry.prefab_entity || override_entry.string_parameter_overrides.empty())
        {
            continue;
        }
 
        std::erase_if(normalized, [&](const PrefabBehaviorOverrideEntry& existing)
                      { return existing.prefab_entity == override_entry.prefab_entity; });
        normalized.push_back(std::move(override_entry));
    }
 
    overrides = std::move(normalized);
}
 
inline Node& operator<<(Node& node, const PrefabBehaviorOverrideEntry& entry)
{
    node["entity"] << entry.prefab_entity;
    if (!entry.string_parameter_overrides.empty())
    {
        node["stringParameterOverrides"] << entry.string_parameter_overrides;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, PrefabBehaviorOverrideEntry& entry)
{
    if (node.HasProperty("entity"))
    {
        node["entity"] >> entry.prefab_entity;
    }
    else
    {
        entry.prefab_entity = EntityId::Invalid();
    }
 
    if (node.HasProperty("stringParameterOverrides"))
    {
        node["stringParameterOverrides"] >> entry.string_parameter_overrides;
    }
    else
    {
        entry.string_parameter_overrides.clear();
    }
 
    NormalizeBehaviorStringParameterOverrides(entry.string_parameter_overrides);
    return node;
}
 
struct PrefabBehaviorOverridesComponent
{
    std::vector<PrefabBehaviorOverrideEntry> behavior_overrides;
 
    [[nodiscard]] const PrefabBehaviorOverrideEntry* FindBehaviorOverride(const EntityId prefab_entity) const noexcept
    {
        const auto it = std::find_if(behavior_overrides.begin(), behavior_overrides.end(),
                                     [&](const PrefabBehaviorOverrideEntry& entry) { return entry.prefab_entity == prefab_entity; });
        return it == behavior_overrides.end() ? nullptr : &(*it);
    }
 
    [[nodiscard]] bool operator==(const PrefabBehaviorOverridesComponent&) const noexcept = default;
};
 
inline Node& operator<<(Node& node, const PrefabBehaviorOverridesComponent& component)
{
    if (!component.behavior_overrides.empty())
    {
        node["behaviorOverrides"] << component.behavior_overrides;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, PrefabBehaviorOverridesComponent& component)
{
    if (node.HasProperty("behaviorOverrides"))
    {
        node["behaviorOverrides"] >> component.behavior_overrides;
    }
    else
    {
        component.behavior_overrides.clear();
    }
 
    NormalizePrefabBehaviorOverrideEntries(component.behavior_overrides);
    return node;
}
} // namespace pixelbullet