RTSSystems_Faction.cpp

浏览该文件的文档.

#include "rts/RTSSystems.h"
 
#include <algorithm>
#include <cmath>
#include <vector>
 
namespace eve::rts {
 
Result<int> VeterancySystem::award(Unit& unit, float experience) {
    auto veterancy = unit.veterancy();
    auto durability = unit.durability();
    auto combatPolicy = unit.combat();
    if (!durability->alive || !std::isfinite(experience) || experience <= 0.0f)
        return Result<int>::failure(
            Diagnostic::error(DiagnosticCode::InvalidArgument,
                              "RTS veterancy award requires a live unit and positive finite experience", "experience"));
    if (veterancy->veteranThreshold <= 0.0f)
        return Result<int>::success(0, Status::success(StatusCode::NoOp));
    if (!std::isfinite(veterancy->experience) || veterancy->experience < 0.0f ||
        !std::isfinite(veterancy->veteranThreshold) || !std::isfinite(veterancy->eliteThreshold) ||
        veterancy->eliteThreshold <= veterancy->veteranThreshold ||
        !std::isfinite(veterancy->veteranDamageFactor) ||
        !std::isfinite(veterancy->eliteDamageFactor) ||
        !std::isfinite(veterancy->veteranHealthFactor) ||
        !std::isfinite(veterancy->eliteHealthFactor) ||
        veterancy->veteranDamageFactor < 1.0f ||
        veterancy->eliteDamageFactor < veterancy->veteranDamageFactor ||
        veterancy->veteranHealthFactor < 1.0f ||
        veterancy->eliteHealthFactor < veterancy->veteranHealthFactor ||
        veterancy->level < 0 || veterancy->level > 2)
        return Result<int>::failure(Diagnostic::error(DiagnosticCode::InvalidArgument,
                                                      "RTS veterancy thresholds and factors are inconsistent",
                                                      "unit.veterancy"));
    veterancy->experience += experience;
    const int oldLevel = veterancy->level;
    if (veterancy->eliteThreshold > 0.0f && veterancy->experience >= veterancy->eliteThreshold)
        veterancy->level = 2;
    else if (veterancy->experience >= veterancy->veteranThreshold)
        veterancy->level = 1;
    if (veterancy->level == oldLevel)
        return Result<int>::success(0, Status::success(StatusCode::Applied));
    const auto damageAt = [&](int level) {
        return level >= 2 ? veterancy->eliteDamageFactor
                          : level >= 1 ? veterancy->veteranDamageFactor : 1.0f;
    };
    const auto healthAt = [&](int level) {
        return level >= 2 ? veterancy->eliteHealthFactor
                          : level >= 1 ? veterancy->veteranHealthFactor : 1.0f;
    };
    combatPolicy->upgradeDamageFactor *= damageAt(veterancy->level) / damageAt(oldLevel);
    const double healthRatio = static_cast<double>(healthAt(veterancy->level) / healthAt(oldLevel));
    durability->state.maxHealth *= healthRatio;
    durability->state.health = std::min(durability->state.maxHealth,
                                        durability->state.health * healthRatio);
    return Result<int>::success(veterancy->level - oldLevel, Status::success(StatusCode::Applied));
}
 
bool FactionRelationSystem::isAllied(Faction* left, Faction* right) noexcept {
    if (left == nullptr || right == nullptr) return false;
    if (left == right) return true;
    auto matches = ecs::View<Match, Match::Participants>();
    for (auto it = matches.begin(); it != matches.end(); ++it) {
        auto [participants] = *it;
        const Match::Participants::Entry* leftEntry = nullptr;
        const Match::Participants::Entry* rightEntry = nullptr;
        for (const auto& entry : participants->entries) {
            if (entry.eliminated) continue;
            if (entry.faction.resolve() == left) leftEntry = &entry;
            if (entry.faction.resolve() == right) rightEntry = &entry;
        }
        if (leftEntry != nullptr && rightEntry != nullptr)
            return leftEntry->team == rightEntry->team;
    }
    return false;
}
 
bool FactionRelationSystem::isAllied(const FactionLink& left, const FactionLink& right) noexcept {
    return isAllied(dynamic_cast<Faction*>(left.resolve()), dynamic_cast<Faction*>(right.resolve()));
}
 
bool FactionIntelSystem::isTargetable(Faction* viewer, SubjectRef subject) noexcept {
    if (viewer == nullptr || !subject.isValid()) return false;
    const auto intel = viewer->intel();
    if (!intel->enabled) return true;
    const auto found = std::find_if(intel->contacts.begin(), intel->contacts.end(),
                                    [&](const auto& contact) { return contact.subject == subject; });
    return found != intel->contacts.end() && found->subject == subject &&
           found->visible && found->detected;
}
 
}  // namespace eve::rts