RTSAttributes.cpp

浏览该文件的文档.

#include "rts/RTSAttributes.h"
 
#include "rts/RTSTypes.h"
 
#include <array>
#include <string>
#include <utility>
 
namespace eve::rts {
namespace {
 
bool selected(std::string_view name) noexcept {
    return name == RTSUnitAttributeAdapter::attackAttribute || name == RTSUnitAttributeAdapter::healthAttribute ||
           name == RTSUnitAttributeAdapter::maxHealthAttribute || name == RTSUnitAttributeAdapter::armorAttribute;
}
 
std::array<std::string_view, 4> selectedAttributes() {
    return {RTSUnitAttributeAdapter::attackAttribute, RTSUnitAttributeAdapter::healthAttribute,
            RTSUnitAttributeAdapter::maxHealthAttribute, RTSUnitAttributeAdapter::armorAttribute};
}
 
}  // namespace
 
eve::Result<void> RTSUnitAttributeAdapter::ensure(Unit& unit) {
    auto bound = unit.attributes()->values.bindOwner(ecs::handle_of(&unit));
    if (!bound) return eve::Result<void>::failure(
        eve::Status::failure(bound.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attribute owner could not be bound", "owner", {}, "rts.attributes")));
    if (!unit.attributes()->values.initialized()) {
        const std::array<eve::attributes::AttributeSnapshotBase, 4> bases = {
            eve::attributes::AttributeSnapshotBase{std::string(attackAttribute), 0.0},
            eve::attributes::AttributeSnapshotBase{std::string(healthAttribute), 100.0},
            eve::attributes::AttributeSnapshotBase{std::string(maxHealthAttribute), 100.0},
            eve::attributes::AttributeSnapshotBase{std::string(armorAttribute), 0.0}};
        auto initialized = unit.attributes()->values.initialize(bases);
        if (!initialized)
            return eve::Result<void>::failure(
        eve::Status::failure(initialized.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attribute state could not be initialized", "attributes", {}, "rts.attributes")));
    }
    return eve::Result<void>::success(eve::Status::success(eve::StatusCode::NoOp));
}
 
eve::Result<double> RTSUnitAttributeAdapter::read(Unit& unit, std::string_view attribute) {
    if (!selected(attribute))
        return eve::Result<double>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::Unsupported, "RTS unit attribute is outside the selective combat projection",
            "attribute", {}, "rts.attributes"));
    auto ready = ensure(unit);
    if (!ready)
        return eve::Result<double>::failure(eve::Status::failure(
            ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attributes are not available",
                                                 "attributes", {}, "rts.attributes")));
    return unit.attributes()->values.getFinal(attribute);
}
 
eve::Result<void> RTSUnitAttributeAdapter::setBase(Unit& unit, std::string_view attribute, double value) {
    if (!selected(attribute))
        return eve::Result<void>::failure(
        eve::Diagnostic::error(eve::DiagnosticCode::Unsupported, "RTS unit attribute is outside the selective combat projection", "attribute", {}, "rts.attributes"));
    auto ready = ensure(unit);
    if (!ready) return eve::Result<void>::failure(
        eve::Status::failure(ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attributes are not available", "attributes", {}, "rts.attributes")));
    return unit.attributes()->values.setBase(attribute, value);
}
 
eve::Result<eve::attributes::ModifierId> RTSUnitAttributeAdapter::addModifier(
    Unit& unit, 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,
            "RTS unit modifier requires a selected attribute and non-empty source", "modifier", {}, "rts.attributes"));
    auto ready = ensure(unit);
    if (!ready)
        return eve::Result<eve::attributes::ModifierId>::failure(eve::Status::failure(
            ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attributes are not available",
                                                 "attributes", {}, "rts.attributes")));
    return unit.attributes()->values.addModifier(eve::attributes::AttributeModifier(
        std::move(id), std::string(attribute), std::move(source), operation, value, priority));
}
 
eve::Result<eve::attributes::AttributeProjectionSnapshot> RTSUnitAttributeAdapter::snapshot(Unit& unit) {
    auto ready = ensure(unit);
    if (!ready)
        return eve::Result<eve::attributes::AttributeProjectionSnapshot>::failure(eve::Status::failure(
            ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attributes are not available",
                                                 "attributes", {}, "rts.attributes")));
    const auto names = selectedAttributes();
    return unit.attributes()->values.snapshot(names);
}
 
eve::Result<void> RTSUnitAttributeAdapter::restore(Unit&                                               unit,
                                                   const eve::attributes::AttributeProjectionSnapshot& snapshotValue,
                                                   eve::Revision expectedRevision) {
    auto ready = ensure(unit);
    if (!ready) return eve::Result<void>::failure(
        eve::Status::failure(ready.code(), eve::Diagnostic::error(eve::DiagnosticCode::Failed, "RTS unit attributes are not available", "attributes", {}, "rts.attributes")));
    return unit.attributes()->values.restore(snapshotValue, expectedRevision);
}
 
}  // namespace eve::rts