CrowdDocument.h

浏览该文件的文档.

#pragma once
#include "common/Export.h"
 
 
#include "editing/EditingAuthority.h"
#include "editing/EditableTarget.h"
 
#include <array>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
namespace eve::crowd_editing {
using CapabilityId=editing::CapabilityId; using DiagnosticSeverity=editing::DiagnosticSeverity;
using DomainOperation=editing::DomainOperation; using EditRegion=editing::EditRegion;
using EditorDiagnostic=editing::Diagnostic; using editing::Result;
using EditorStatus=editing::Status; using EditorValue=editing::Value;
using IDomainOperationTarget=editing::IDomainOperationTarget;
using IDomainOperationTargetStaging=editing::IDomainOperationTargetStaging;
using IEditableTarget=editing::IEditableTarget; using Revision=editing::Revision;
using RuleId=editing::RuleId; using StableId=editing::StableId;
using TargetDescriptor=editing::TargetDescriptor; using TargetId=editing::TargetId;
 
struct CrowdAgentRecord {
    StableId id;
    std::string archetype;
    double x = 0.0, y = 0.0;
    double heading = 0.0;
    double radius = 0.5;
    double maximumSpeed = 4.0;
    std::string behavior = "idle";
    StableId path;
};
 
struct CrowdZoneRecord {
    StableId id;
    std::string name;
    std::string kind = "avoid";
    std::vector<std::array<double, 2>> points;
    double weight = 1.0;
    bool enabled = true;
};
 
struct CrowdWaypointRecord {
    StableId id;
    double x = 0.0, y = 0.0;
    double arriveRadius = 1.0;
    double waitSeconds = 0.0;
};
 
struct CrowdPathRecord {
    StableId id;
    std::string name;
    bool loop = false;
    std::vector<CrowdWaypointRecord> points;
};
 
struct CrowdOverlayPrimitive {
    std::string kind;
    StableId object;
    std::vector<double> values;
    std::string label;
};
 
struct CrowdOverlayResult {
    EditorStatus status = EditorStatus::Failed;
    Revision revision = 0;
    std::vector<CrowdOverlayPrimitive> primitives;
    std::vector<EditorDiagnostic> diagnostics;
};
 
class EVENGINE_API_BACKENDS CrowdDocumentTarget final : public ::eve::editing::EditableTargetState,
                                                        public virtual IEditableTarget,
                                                        public IDomainOperationTarget,
                                                        public IDomainOperationTargetStaging {
public:
    static CapabilityId editorCapabilityId() { return CapabilityId("eve.editor.target.crowd-structure"); }
    explicit CrowdDocumentTarget(std::string id);
    TargetId         targetId() const override { return TargetId(id_); }
    TargetDescriptor describe() const override;
    void* queryCapability(const CapabilityId& capability) override;
    Result<void> applyDomainOperation(const DomainOperation& operation) override;
    [[nodiscard]] std::unique_ptr<IDomainOperationTarget> cloneDomainState() const override;
    [[nodiscard]] Result<void> commitDomainState(
        std::unique_ptr<IDomainOperationTarget> candidate) override;
 
    std::vector<CrowdAgentRecord> agents() const;
    std::vector<CrowdZoneRecord> zones() const;
    std::vector<CrowdPathRecord> paths() const;
    Result<DomainOperation> makeSetAgent(const CrowdAgentRecord& record) const;
    Result<DomainOperation> makeDeleteAgent(const StableId& id) const;
    Result<DomainOperation> makeSetZone(const CrowdZoneRecord& record) const;
    Result<DomainOperation> makeDeleteZone(const StableId& id) const;
    Result<DomainOperation> makeSetPath(const CrowdPathRecord& record) const;
    Result<DomainOperation> makeDeletePath(const StableId& id) const;
    std::vector<EditorDiagnostic> validate() const;
    CrowdOverlayResult overlay(int primitiveBudget = 100000) const;
    EditorValue snapshotValue() const;
    Result<void> loadSnapshot(const EditorValue& snapshot);
 
private:
    std::string                          id_;
    std::map<StableId, CrowdAgentRecord> agents_;
    std::map<StableId, CrowdZoneRecord> zones_;
    std::map<StableId, CrowdPathRecord> paths_;
};
 
}  // namespace eve::crowd_editing
 
namespace eve::crowd { class Crowd; }
 
namespace eve::crowd_editing {
 
class EVENGINE_API_BACKENDS CrowdRuntimeApplier {
public:
    Result<void> apply(const CrowdDocumentTarget& document, crowd::Crowd* runtime) const;
};
 
}  // namespace eve::crowd_editing