WeaponDefinitionRuntime.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "common/Snapshot.h"
#include "common/definitions/DefinitionRuntime.h"
#include "common/definitions/RuntimeSnapshot.h"
#include "definitions/Definitions.h"
#include "weapon/WeaponTypes.h"
 
#include <string>
#include <string_view>
 
namespace eve::weapon {
 
class Weapon;
 
[[nodiscard]] EVENGINE_API_WORLD eve::Result<WeaponDefinition> parseWeaponDefinition(
    const eve::definitions::Definition& source);
 
struct WeaponRuntimeState {
    Resource    resource;
    float       cooldown       = 0.f;
    int         burstRemaining = 0;
    float       burstTimer     = 0.f;
    bool        jammed         = false;
    AttackStage stage          = AttackStage::Idle;
    float       stageTimer     = 0.f;
    float       currentSpread  = 0.f;
    float       recoilPitch    = 0.f;
    float       recoilYaw      = 0.f;
    FireMode    selector       = FireMode::Single;
    bool        aiming         = false;
};
 
class EVENGINE_API_WORLD WeaponDefinitionRuntime final {
public:
    [[nodiscard]] static eve::Result<WeaponDefinitionRuntime> create(
        eve::definitions::DefinitionRegistry& registry, eve::DefinitionRef definition, eve::PersistentId instanceId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::RebuildInstance);
 
    [[nodiscard]] static eve::Result<WeaponDefinitionRuntime> create(
        eve::definitions::DefinitionRegistry& registry, std::string_view definitionId, eve::PersistentId instanceId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::RebuildInstance);
 
    [[nodiscard]] static eve::Result<WeaponDefinitionRuntime> create(
        Weapon& module, std::string_view definitionId, eve::PersistentId instanceId,
        eve::definition::ReloadPolicy policy = eve::definition::ReloadPolicy::RebuildInstance);
 
    WeaponDefinitionRuntime(WeaponDefinitionRuntime&&) noexcept            = default;
    WeaponDefinitionRuntime& operator=(WeaponDefinitionRuntime&&) noexcept = default;
    WeaponDefinitionRuntime(const WeaponDefinitionRuntime&)                = delete;
    WeaponDefinitionRuntime& operator=(const WeaponDefinitionRuntime&)     = delete;
    ~WeaponDefinitionRuntime()                                             = default;
 
    [[nodiscard]] const eve::definition::InstanceIdentity& identity() const noexcept;
    [[nodiscard]] const WeaponRuntimeState& state() const noexcept;
    [[nodiscard]] WeaponRuntimeState& state() noexcept;
    [[nodiscard]] eve::definition::DefinitionHandle definitionHandle() const noexcept;
    [[nodiscard]] eve::Result<WeaponDefinition> definition() const;
    [[nodiscard]] eve::definition::ReloadPolicy reloadPolicy() const noexcept { return policy_; }
    void setActive(bool active) noexcept;
    [[nodiscard]] bool isActive() const noexcept;
 
    [[nodiscard]] eve::Result<void> applyTo(WeaponEntity* entity) const;
 
    [[nodiscard]] eve::Result<eve::definition::ReloadOutcome> reload(eve::definition::ReloadPolicy policy);
 
    [[nodiscard]] eve::Result<eve::SnapshotEnvelope> snapshot(eve::Revision revision, eve::SimulationTick tick,
                                                              const eve::SnapshotHashProvider& hashProvider) const;
    [[nodiscard]] eve::Result<std::string> snapshotJson(eve::Revision revision, eve::SimulationTick tick,
                                                        const eve::SnapshotHashProvider& hashProvider) const;
    [[nodiscard]] eve::Result<void> restore(const eve::SnapshotEnvelope&     snapshot,
                                            const eve::SnapshotHashProvider& hashProvider);
 
private:
    WeaponDefinitionRuntime(eve::definitions::DefinitionRegistry&                registry,
                            eve::definition::RuntimeInstance<WeaponRuntimeState> runtime,
                            eve::definition::ReloadPolicy                        policy)
        : registry_(&registry), runtime_(std::move(runtime)), policy_(policy) {}
 
    eve::definitions::DefinitionRegistry*                registry_ = nullptr;  // borrowed
    eve::definition::RuntimeInstance<WeaponRuntimeState> runtime_;
    eve::definition::ReloadPolicy                        policy_ = eve::definition::ReloadPolicy::RebuildInstance;
};
 
}  // namespace eve::weapon