RPGActor.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/ECS.h"
#include "rpg/AttributeTypes.h"
#include "rpg/StatusTypes.h"
#include "rpg/SkillTypes.h"
 
#include <string>
#include <string_view>
#include <unordered_map>
#include <vector>
 
namespace eve::rpg {
 
class RPGSaveSession;
class Party;
 
class EVENGINE_API_PLATFORM RPGActor : public ecs::Entity {
public:
    ENTITY(RPGActor, ecs::Entity)
 
    
    void release() override { ecs::DestroyEntity(this); }
 
    struct Attributes {
        Attributes() : values(std::string{}) {}
 
        ::eve::attributes::AttributeSet values;
    };
 
    struct Statuses {
        ::eve::effects::EffectContainer                         container;
        std::unordered_map<std::string, StatusExecutorMetadata> metadata;
        std::unordered_map<std::string, int>                    legacyIdByEffect;
        std::unordered_map<int, std::string>                    effectByLegacyId;
        int nextInstanceId = 1;
    };
 
    struct Skills {
        std::unordered_map<std::string, SkillRuntime> known;
        CastingState casting;
    };
 
    struct Progression {
        int level = 1;
        double xp = 0.0;
        double xpToNext = 100.0;  
    };
 
    struct Vitals {
        std::unordered_map<std::string, double> current;
    };
 
    struct TraitInstance {
        int instanceId = 0;
        std::string traitId;
        std::string source;
    };
 
    struct Traits {
        std::vector<TraitInstance> active;
        int nextInstanceId = 1;
    };
 
    struct ClassInfo {
        std::string classId;
        int skillsSyncedUpTo = 0;  
    };
 
    COMPONENT(Attributes, attributes)
    COMPONENT(Statuses, statuses)
    COMPONENT(Skills, skills)
    COMPONENT(Progression, progression)
    COMPONENT(Vitals, vitals)
    COMPONENT(Traits, traits)
    COMPONENT(ClassInfo, classInfo)
 
    
    static RPGActor *createActor();
 
    void setBaseAttribute(const std::string &attribute, double value);
    double getBaseAttribute(const std::string &attribute);
    void modifyBaseAttribute(const std::string &attribute, double delta);
    bool hasAttribute(const std::string &attribute);
    [[nodiscard]] eve::Result<ModifierId> addAttributeModifier(AttributeModifier modifier);
    std::string addAttributeModifier(const std::string &attribute, const std::string &source, const std::string &op,
                                     double value, int priority = 0);
    [[nodiscard]] eve::Result<void> removeAttributeModifier(const ModifierId &modifierId);
    bool removeAttributeModifier(const std::string &attribute, const std::string &modifierId);
    int removeAttributeModifiersBySource(const std::string &attribute, const std::string &source);
    int removeAllAttributeModifiersBySource(const std::string &source);
    double getFinalAttribute(const std::string &attribute);
 
    int applyEffect(const std::string &effectId, const std::string &source = "");
    bool removeStatus(int instanceId);
    int removeStatusByEffect(const std::string &effectId);
    int removeStatusBySource(const std::string &source);
    int removeStatusByTag(const std::string &tag);
    bool hasEffect(const std::string &effectId);
    bool hasStatusTag(const std::string &tag);
    int getStatusCount();
    std::string getStatusEffectId(int index);
    int getStatusStacks(int index);
    float getStatusRemaining(int index);
    int getStatusInstanceId(int index);
    std::string getStatusSource(int index);
    std::string getStatusProp(int instanceId, const std::string &key,
                              const std::string &fallback = {});
    bool setStatusProp(int instanceId, const std::string &key, const std::string &value);
 
    int applyBuff(const std::string &effectId, const std::string &source = "");
    bool removeBuff(int instanceId);
    int removeBuffByEffect(const std::string &effectId);
    int removeBuffBySource(const std::string &source);
    int removeBuffByTag(const std::string &tag);
    bool hasBuff(const std::string &effectId);
    bool hasBuffTag(const std::string &tag);
    int getBuffCount();
    std::string getBuffEffectId(int index);
    int getBuffStacks(int index);
    float getBuffRemaining(int index);
    int getBuffInstanceId(int index);
    std::string getBuffSource(int index);
    std::string getBuffProp(int instanceId, const std::string &key,
                            const std::string &fallback = {});
    bool setBuffProp(int instanceId, const std::string &key, const std::string &value);
 
    void learnSkill(const std::string &skillId);
    bool knowsSkill(const std::string &skillId);
    bool forgetSkill(const std::string &skillId);
    float getSkillCooldown(const std::string &skillId);
    void setSkillCooldown(const std::string &skillId, float seconds);
    bool canCastSkill(const std::string &skillId);
    std::string canCastSkillReason(const std::string &skillId);
    bool beginCastSkill(const std::string &skillId, RPGActor *target = nullptr);
    void cancelCastSkill();
    bool isCastingSkill();
    std::string getCastingSkillId();
    float getCastProgress();
 
    int getLevel();
    double getXp();
    double getXpToNext();
    void setXpToNext(double value);
    [[nodiscard]] eve::Result<void> restoreProgression(int level, double xp, double xpToNext);
    bool gainXp(double amount);
 
    double getCurrent(const std::string &resource);
    double getMax(const std::string &resource);
    void setCurrent(const std::string &resource, double value);
    double takeDamage(const std::string &resource, double amount, const std::string &source = "");
    double heal(const std::string &resource, double amount);
    void revive(const std::string &resource, double amount = -1.0);
    bool isDead(const std::string &resource);
 
    int applyTrait(const std::string &traitId, const std::string &source = "");
    bool removeTrait(int instanceId);
    int removeTraitsBySource(const std::string &source);
    int removeTraitsByTrait(const std::string &traitId);
    bool hasTrait(const std::string &traitId);
    int getTraitCount();
    int getTraitInstanceIdAt(int index);
    std::string getTraitIdAt(int index);
    std::string getTraitSourceAt(int index);
    double getParamRate(const std::string &param);
    double getElementRate(const std::string &element);
    double getStateRate(const std::string &stateId);
    bool isStateResist(const std::string &stateId);
    double getExParam(const std::string &exParam);
    double getAttackSpeed();
    int getAttackTimesAdd();
    std::vector<std::string> getAttackElements();
    std::vector<std::string> getAttackStates();
 
    bool setClass(const std::string &classId);
    std::string getClassId();
    bool hasClass(const std::string &classId);
    int checkLevelSkills();
    int getClassLearnCount();
    std::string getClassLearnSkillIdAt(int index);
    int getClassLearnLevelAt(int index);
 
    [[nodiscard]] eve::Result<std::string> checkpointJson() const;
 
    [[nodiscard]] eve::Result<void> restoreCheckpointJson(std::string_view json);
 
    static const std::vector<RPGActor *> &liveActors();
 
private:
    struct CheckpointCandidate {
        Attributes attributes;
        Skills skills;
        Progression progression;
        Vitals vitals;
        ClassInfo classInfo;
    };
 
    [[nodiscard]] eve::Result<CheckpointCandidate> prepareCheckpointJson(std::string_view json) const;
    void commitCheckpoint(CheckpointCandidate candidate) noexcept;
    friend class RPGSaveSession;
    friend class Party;
};
 
}  // namespace eve::rpg