WeaponAttributes.cpp

浏览该文件的文档.

#include "weapon/WeaponAttributes.h"
 
#include "weapon/WeaponTypes.h"
 
#include <algorithm>
#include <array>
#include <cmath>
#include <limits>
#include <string>
#include <utility>
 
namespace eve::weapon {
namespace {
 
bool selected(std::string_view name) noexcept {
    return name == WeaponAttributeAdapter::manaAttribute || name == WeaponAttributeAdapter::maxManaAttribute ||
           name == WeaponAttributeAdapter::staminaAttribute || name == WeaponAttributeAdapter::maxStaminaAttribute;
}
 
std::array<std::string_view, 4> selectedAttributes() {
    return {WeaponAttributeAdapter::manaAttribute, WeaponAttributeAdapter::maxManaAttribute,
            WeaponAttributeAdapter::staminaAttribute, WeaponAttributeAdapter::maxStaminaAttribute};
}
 
bool isManaOrStamina(ResourceKind kind) noexcept { return kind == ResourceKind::Mana || kind == ResourceKind::Stamina; }
 
std::string_view currentAttribute(ResourceKind kind) noexcept {
    return kind == ResourceKind::Mana ? WeaponAttributeAdapter::manaAttribute
                                      : WeaponAttributeAdapter::staminaAttribute;
}
 
std::string_view maxAttribute(ResourceKind kind) noexcept {
    return kind == ResourceKind::Mana ? WeaponAttributeAdapter::maxManaAttribute
                                      : WeaponAttributeAdapter::maxStaminaAttribute;
}
 
}  // namespace
 
eve::Result<void> WeaponAttributeAdapter::ensure(WeaponEntity& weapon) {
    auto bound = weapon.attributes()->values.bindOwner(ecs::handle_of(&weapon));
    if (!bound) return eve::Result<void>::failure(
        eve::Status::failure(bound.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attribute owner could not be bound", "owner", {}, "weapon.attributes")));
    if (!weapon.attributes()->values.initialized()) {
        const Resource& resource   = weapon.state()->resource;
        const double    mana       = resource.kind == ResourceKind::Mana ? resource.value : 0.0;
        const double    maxMana    = resource.kind == ResourceKind::Mana ? resource.max : 0.0;
        const double    stamina    = resource.kind == ResourceKind::Stamina ? resource.value : 0.0;
        const double    maxStamina = resource.kind == ResourceKind::Stamina ? resource.max : 0.0;
        const std::array<eve::attributes::AttributeSnapshotBase, 4> bases = {
            eve::attributes::AttributeSnapshotBase{std::string(manaAttribute), mana},
            eve::attributes::AttributeSnapshotBase{std::string(maxManaAttribute), maxMana},
            eve::attributes::AttributeSnapshotBase{std::string(staminaAttribute), stamina},
            eve::attributes::AttributeSnapshotBase{std::string(maxStaminaAttribute), maxStamina}};
        auto initialized = weapon.attributes()->values.initialize(bases);
        if (!initialized)
            return eve::Result<void>::failure(
        eve::Status::failure(initialized.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attribute state could not be initialized", "attributes", {}, "weapon.attributes")));
    }
    return eve::Result<void>::success(eve::Status::success(eve::StatusCode::NoOp));
}
 
eve::Result<void> WeaponAttributeAdapter::project(WeaponEntity& weapon) {
    auto ready = ensure(weapon);
    if (!ready) return eve::Result<void>::failure(
        eve::Status::failure(ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attributes are not available", "attributes", {}, "weapon.attributes")));
    Resource& resource = weapon.state()->resource;
    if (!isManaOrStamina(resource.kind)) return eve::Result<void>::success(eve::Status::success(eve::StatusCode::NoOp));
    auto current = weapon.attributes()->values.getFinal(currentAttribute(resource.kind));
    if (!current) return eve::Result<void>::failure(
        eve::Status::failure(current.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon resource attribute could not be read", "resource", {}, "weapon.attributes")));
    auto maximum = weapon.attributes()->values.getFinal(maxAttribute(resource.kind));
    if (!maximum) return eve::Result<void>::failure(
        eve::Status::failure(maximum.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon maximum resource attribute could not be read", "resource", {}, "weapon.attributes")));
    if (!std::isfinite(current.value()) || !std::isfinite(maximum.value()) || current.value() < 0.0 ||
        maximum.value() < 0.0 || current.value() > maximum.value() ||
        maximum.value() > static_cast<double>(std::numeric_limits<float>::max()))
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::InvariantViolation, "weapon mana/stamina attributes are outside validated bounds", "resource", {}, "weapon.attributes"));
    resource.value = static_cast<float>(current.value());
    resource.max   = static_cast<float>(maximum.value());
    return eve::Result<void>::success(eve::Status::success(eve::StatusCode::Applied));
}
 
eve::Result<double> WeaponAttributeAdapter::read(WeaponEntity& weapon, std::string_view attribute) {
    if (!selected(attribute))
        return eve::Result<double>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::Unsupported, "weapon attribute is outside the mana/stamina projection", "attribute",
            {}, "weapon.attributes"));
    auto projected = project(weapon);
    if (!projected)
        return eve::Result<double>::failure(eve::Status::failure(
            projected.code(),
            eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon compatibility projection failed", "resource",
                                   {}, "weapon.attributes")));
    auto value = weapon.attributes()->values.getFinal(attribute);
    if (!value)
        return eve::Result<double>::failure(eve::Status::failure(
            value.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attribute read failed",
                                                 "attribute", {}, "weapon.attributes")));
    return eve::Result<double>::success(value.value());
}
 
eve::Result<void> WeaponAttributeAdapter::setBase(WeaponEntity& weapon, std::string_view attribute, double value) {
    if (!selected(attribute))
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Unsupported, "weapon attribute is outside the mana/stamina projection", "attribute", {}, "weapon.attributes"));
    auto ready = ensure(weapon);
    if (!ready) return eve::Result<void>::failure(
        eve::Status::failure(ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attributes are not available", "attributes", {}, "weapon.attributes")));
    auto changed = weapon.attributes()->values.setBase(attribute, value);
    if (!changed) return changed;
    return project(weapon);
}
 
eve::Result<void> WeaponAttributeAdapter::consumeTriggerResource(WeaponEntity& weapon) {
    auto ready = ensure(weapon);
    if (!ready) return eve::Result<void>::failure(
        eve::Status::failure(ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attributes are not available", "attributes", {}, "weapon.attributes")));
    const Resource& resource = weapon.state()->resource;
    if (!isManaOrStamina(resource.kind))
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Unsupported, "weapon trigger resource is not mana or stamina", "resource.kind", {}, "weapon.attributes"));
    const auto currentName = currentAttribute(resource.kind);
    auto       current     = weapon.attributes()->values.getFinal(currentName);
    if (!current) return eve::Result<void>::failure(
        eve::Status::failure(current.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon trigger resource could not be read", "resource", {}, "weapon.attributes")));
    if (!resource.infinite && current.value() < static_cast<double>(resource.cost))
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Conflict, "weapon does not have enough mana or stamina", "resource", {}, "weapon.attributes"));
    if (resource.infinite) return eve::Result<void>::success(eve::Status::success(eve::StatusCode::NoOp));
    auto changed = weapon.attributes()->values.setBase(
        currentName, std::max(0.0, current.value() - static_cast<double>(resource.cost)));
    if (!changed) return changed;
    return project(weapon);
}
 
eve::Result<eve::attributes::ModifierId> WeaponAttributeAdapter::addModifier(
    WeaponEntity& weapon, std::string id, std::string_view attribute, std::string source,
    eve::attributes::AttributeOperation operation, double value, eve::attributes::ModifierPriority priority) {
    if (!selected(attribute) || source.empty())
        return eve::Result<eve::attributes::ModifierId>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "weapon modifier requires a selected attribute and non-empty source",
            "modifier", {}, "weapon.attributes"));
    auto ready = ensure(weapon);
    if (!ready)
        return eve::Result<eve::attributes::ModifierId>::failure(eve::Status::failure(
            ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attributes are not available",
                                                 "attributes", {}, "weapon.attributes")));
    auto added = weapon.attributes()->values.addModifier(eve::attributes::AttributeModifier(
        std::move(id), std::string(attribute), std::move(source), operation, value, priority));
    if (!added) return added;
    auto projected = project(weapon);
    if (!projected)
        return eve::Result<eve::attributes::ModifierId>::failure(eve::Status::failure(
            projected.code(),
            eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon compatibility projection failed", "resource",
                                   {}, "weapon.attributes")));
    return added;
}
 
eve::Result<eve::attributes::AttributeProjectionSnapshot> WeaponAttributeAdapter::snapshot(WeaponEntity& weapon) {
    auto ready = ensure(weapon);
    if (!ready)
        return eve::Result<eve::attributes::AttributeProjectionSnapshot>::failure(eve::Status::failure(
            ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attributes are not available",
                                                 "attributes", {}, "weapon.attributes")));
    const auto names = selectedAttributes();
    return weapon.attributes()->values.snapshot(names);
}
 
eve::Result<void> WeaponAttributeAdapter::restore(WeaponEntity&                                       weapon,
                                                  const eve::attributes::AttributeProjectionSnapshot& snapshotValue,
                                                  eve::Revision expectedRevision) {
    auto ready = ensure(weapon);
    if (!ready) return eve::Result<void>::failure(
        eve::Status::failure(ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "weapon attributes are not available", "attributes", {}, "weapon.attributes")));
    auto restored = weapon.attributes()->values.restore(snapshotValue, expectedRevision);
    if (!restored) return restored;
    return project(weapon);
}
 
}  // namespace eve::weapon