AbilitySystem.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "action/Action.h"
#include "common/StrongUint64.h"
#include "tags/GameplayTag.h"
 
#include <map>
#include <string>
#include <string_view>
#include <vector>
 
namespace eve::action {
 
enum class AbilityInstancingPolicy : std::uint8_t { NonInstanced, PerOwner, PerExecution };
 
enum class AbilityActivationGroup : std::uint8_t { Independent, ExclusiveReplaceable, ExclusiveBlocking };
 
struct AbilityTrigger {
    std::string            gameplayTag;
    tags::GameplayTagMatch match = tags::GameplayTagMatch::Exact;
};
 
struct EVENGINE_API_PLATFORM AbilityDefinition {
    LogicalId                   id;
    ActionDefinition            action;
    Duration                    cooldown        = Duration::zero();
    AbilityInstancingPolicy     instancing      = AbilityInstancingPolicy::PerOwner;
    AbilityActivationGroup      activationGroup = AbilityActivationGroup::Independent;
    std::vector<AbilityTrigger> triggers;
 
    [[nodiscard]] Result<void> validate() const;
};
 
struct AbilityGrantIdTag;
struct AbilityActivationIdTag;
struct AbilityInstanceIdTag;
using AbilityGrantId = eve::detail::StrongUint64<AbilityGrantIdTag>;
using AbilityActivationId = eve::detail::StrongUint64<AbilityActivationIdTag>;
using AbilityInstanceId = eve::detail::StrongUint64<AbilityInstanceIdTag>;
 
struct AbilityGrantState {
    AbilityGrantId grantId;
    std::string    ownerId;
    LogicalId      definitionId;
    Duration       cooldownRemaining = Duration::zero();
};
 
struct AbilityActivation {
    AbilityActivationId    id;
    AbilityGrantId         grantId;
    AbilityInstanceId      instanceId;
    ActionExecutionId      executionId;
    std::string            ownerId;
    AbilityActivationGroup group = AbilityActivationGroup::Independent;
};
 
class EVENGINE_API_PLATFORM AbilityRuntime {
public:
    explicit AbilityRuntime(ActionRuntime& runtime) : runtime_(runtime) {}
 
    [[nodiscard]] Result<void> registerDefinition(AbilityDefinition definition);
    [[nodiscard]] Result<void> replaceDefinition(AbilityDefinition definition);
    [[nodiscard]] Result<AbilityGrantId> grant(std::string ownerId, const LogicalId& definitionId);
    [[nodiscard]] Result<void> revoke(AbilityGrantId grantId);
    [[nodiscard]] Result<AbilityGrantState> findGrant(AbilityGrantId grantId) const;
 
    [[nodiscard]] Result<AbilityActivation> activate(AbilityGrantId grantId, ActionRequest request,
                                                     SimulationTick tick);
    [[nodiscard]] std::vector<AbilityGrantId> matchingGrants(std::string_view ownerId,
                                                             std::string_view gameplayEventTag) const;
    [[nodiscard]] Result<void> advanceCooldowns(Duration delta);
    [[nodiscard]] Result<std::size_t> synchronize();
    [[nodiscard]] std::vector<AbilityActivation> activeActivations() const;
 
private:
    struct GrantRecord {
        AbilityGrantState state;
        AbilityInstanceId ownerInstanceId;
    };
 
    [[nodiscard]] Result<AbilityGrantId>      nextGrantId();
    [[nodiscard]] Result<AbilityActivationId> nextActivationId();
    [[nodiscard]] Result<AbilityInstanceId>   nextInstanceId();
    [[nodiscard]] bool                        grantHasActiveActivation(AbilityGrantId grantId) const;
 
    ActionRuntime&                                   runtime_;
    std::map<std::string, AbilityDefinition>         definitions_;
    std::map<AbilityGrantId, GrantRecord>            grants_;
    std::map<AbilityActivationId, AbilityActivation> activations_;
    AbilityGrantId                                   nextGrant_{1};
    AbilityActivationId                              nextActivation_{1};
    AbilityInstanceId                                nextInstance_{1};
};
 
}  // namespace eve::action