goal_volume_component.h

#pragma once
 
#include "pixelbullet/filesystem/virtual_path_serialization.h"
#include "pixelbullet/serialization/node.h"
 
#include <string>
#include <vector>
 
namespace pixelbullet
{
struct GoalVolumeComponent
{
    bool enabled = true;
    int required_key_count = 0;
    std::vector<std::string> required_key_ids;
    VirtualPath next_scene;
 
    [[nodiscard]] bool operator==(const GoalVolumeComponent& other) const noexcept
    {
        return enabled == other.enabled && required_key_count == other.required_key_count &&
               required_key_ids == other.required_key_ids &&
               next_scene.LogicalPath() == other.next_scene.LogicalPath();
    }
};
 
inline Node& operator<<(Node& node, const GoalVolumeComponent& component)
{
    node["enabled"] << component.enabled;
    if (component.required_key_count > 0)
    {
        node["requiredKeyCount"] << component.required_key_count;
    }
    if (!component.required_key_ids.empty())
    {
        node["requiredKeyIds"] << component.required_key_ids;
    }
    if (!component.next_scene.Empty())
    {
        node["nextScene"] << component.next_scene;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, GoalVolumeComponent& component)
{
    if (node.HasProperty("enabled"))
    {
        node["enabled"] >> component.enabled;
    }
    else
    {
        component.enabled = true;
    }
 
    if (node.HasProperty("requiredKeyCount"))
    {
        node["requiredKeyCount"] >> component.required_key_count;
    }
    else
    {
        component.required_key_count = 0;
    }
 
    if (node.HasProperty("requiredKeyIds"))
    {
        node["requiredKeyIds"] >> component.required_key_ids;
    }
    else
    {
        component.required_key_ids.clear();
    }
 
    if (node.HasProperty("nextScene"))
    {
        node["nextScene"] >> component.next_scene;
    }
    else
    {
        component.next_scene = VirtualPath{};
    }
 
    return node;
}
} // namespace pixelbullet