melee_attack_component.h

#pragma once
 
#include "pixelbullet/serialization/node.h"
 
#include <algorithm>
 
namespace pixelbullet
{
enum class MeleeAttackTimingMode
{
    Seconds,
    AnimationNotify,
};
 
struct MeleeAttackComponent
{
    bool enabled = true;
    float attack_range = 1.25f;
    float windup_seconds = 0.35f;
    float cooldown_seconds = 0.85f;
    int damage_amount = 1;
    MeleeAttackTimingMode timing_mode = MeleeAttackTimingMode::Seconds;
    std::string impact_notify_id;
 
    [[nodiscard]] bool operator==(const MeleeAttackComponent&) const noexcept = default;
};
 
inline Node& operator<<(Node& node, const MeleeAttackTimingMode mode)
{
    node << (mode == MeleeAttackTimingMode::AnimationNotify ? "AnimationNotify" : "Seconds");
    return node;
}
 
inline const Node& operator>>(const Node& node, MeleeAttackTimingMode& mode)
{
    std::string token;
    node >> token;
    mode = token == "AnimationNotify" ? MeleeAttackTimingMode::AnimationNotify : MeleeAttackTimingMode::Seconds;
    return node;
}
 
inline Node& operator<<(Node& node, const MeleeAttackComponent& component)
{
    node["enabled"] << component.enabled;
    node["attackRange"] << component.attack_range;
    node["windupSeconds"] << component.windup_seconds;
    node["cooldownSeconds"] << component.cooldown_seconds;
    node["damageAmount"] << component.damage_amount;
    node["timingMode"] << component.timing_mode;
    if (component.timing_mode == MeleeAttackTimingMode::AnimationNotify && !component.impact_notify_id.empty())
    {
        node["impactNotifyId"] << component.impact_notify_id;
    }
    return node;
}
 
inline const Node& operator>>(const Node& node, MeleeAttackComponent& component)
{
    if (node.HasProperty("enabled"))
    {
        node["enabled"] >> component.enabled;
    }
    else
    {
        component.enabled = true;
    }
 
    if (node.HasProperty("attackRange"))
    {
        node["attackRange"] >> component.attack_range;
    }
    else
    {
        component.attack_range = 1.25f;
    }
 
    if (node.HasProperty("windupSeconds"))
    {
        node["windupSeconds"] >> component.windup_seconds;
    }
    else
    {
        component.windup_seconds = 0.35f;
    }
 
    if (node.HasProperty("cooldownSeconds"))
    {
        node["cooldownSeconds"] >> component.cooldown_seconds;
    }
    else
    {
        component.cooldown_seconds = 0.85f;
    }
 
    if (node.HasProperty("damageAmount"))
    {
        node["damageAmount"] >> component.damage_amount;
    }
    else
    {
        component.damage_amount = 1;
    }
 
    if (node.HasProperty("timingMode"))
    {
        node["timingMode"] >> component.timing_mode;
    }
    else
    {
        component.timing_mode = MeleeAttackTimingMode::Seconds;
    }
 
    if (node.HasProperty("impactNotifyId"))
    {
        node["impactNotifyId"] >> component.impact_notify_id;
    }
    else
    {
        component.impact_notify_id.clear();
    }
 
    component.attack_range = std::max(component.attack_range, 0.0001f);
    component.windup_seconds = std::max(component.windup_seconds, 0.0f);
    component.cooldown_seconds = std::max(component.cooldown_seconds, 0.0f);
    component.damage_amount = std::max(component.damage_amount, 1);
    if (component.timing_mode == MeleeAttackTimingMode::Seconds)
    {
        component.impact_notify_id.clear();
    }
    return node;
}
} // namespace pixelbullet