HouseGenTarget.cpp

浏览该文件的文档.

#include "procgen/editing/HouseGenTarget.h"
 
#include "procgen/house/HouseComponentLibrary.h"
 
#include <algorithm>
#include <cmath>
#include <set>
#include <utility>
 
namespace eve::housegen_editing {
namespace {
const EditorValue* field(const EditorValue& value, const char* key) {
    const auto* object = value.getIf<EditorValue::Object>();
    if (!object) return nullptr;
    const auto it = object->find(key);
    return it == object->end() ? nullptr : &it->second;
}
std::string directionName(housegen::SocketDirection d) {
    switch (d) {
        case housegen::SocketDirection::North: return "north";
        case housegen::SocketDirection::East: return "east";
        case housegen::SocketDirection::South: return "south";
        case housegen::SocketDirection::West: return "west";
        case housegen::SocketDirection::Up: return "up";
        case housegen::SocketDirection::Down: return "down";
    }
    return "north";
}
bool direction(const std::string& s, housegen::SocketDirection& d) {
    if (s == "north")
        d = housegen::SocketDirection::North;
    else if (s == "east")
        d = housegen::SocketDirection::East;
    else if (s == "south")
        d = housegen::SocketDirection::South;
    else if (s == "west")
        d = housegen::SocketDirection::West;
    else if (s == "up")
        d = housegen::SocketDirection::Up;
    else if (s == "down")
        d = housegen::SocketDirection::Down;
    else
        return false;
    return true;
}
EditorValue strings(const std::vector<std::string>& values) {
    EditorValue::Array out;
    for (const auto& v : values) out.push_back(v);
    return out;
}
EditorValue integers(const std::vector<int>& values) {
    EditorValue::Array out;
    for (int v : values) out.push_back(int64_t{v});
    return out;
}
bool readStrings(const EditorValue* value, std::vector<std::string>& out) {
    const auto* array = value ? value->getIf<EditorValue::Array>() : nullptr;
    if (!array) return false;
    out.clear();
    for (const auto& v : *array) {
        const auto* s = v.getIf<std::string>();
        if (!s) return false;
        out.push_back(*s);
    }
    return true;
}
bool readIntegers(const EditorValue* value, std::vector<int>& out) {
    const auto* array = value ? value->getIf<EditorValue::Array>() : nullptr;
    if (!array) return false;
    out.clear();
    for (const auto& v : *array) {
        const auto* n = v.getIf<int64_t>();
        if (!n) return false;
        out.push_back(static_cast<int>(*n));
    }
    return true;
}
EditorValue materialValue(const housegen::HouseMaterialOverride& m) {
    return EditorValue::Object{
        {"hasBaseColor", m.hasBaseColor},
        {"baseColor", EditorValue::Array{m.baseColorR, m.baseColorG, m.baseColorB, m.baseColorA}},
        {"baseColorTexture", m.baseColorTexture},
        {"normalTexture", m.normalTexture},
        {"heightTexture", m.heightTexture},
        {"hasMetallic", m.hasMetallic},
        {"metallic", m.metallic},
        {"hasRoughness", m.hasRoughness},
        {"roughness", m.roughness},
        {"parallaxScale", m.parallaxScale},
        {"parallaxMinLayers", m.parallaxMinLayers},
        {"parallaxMaxLayers", m.parallaxMaxLayers},
        {"cellBombScale", m.cellBombScale},
        {"cellBombStrength", m.cellBombStrength},
        {"cellBombRotation", m.cellBombRotation}};
}
EditorValue componentValue(const HouseKitComponentValue& value) {
    const auto&        c = value.component;
    EditorValue::Array sockets;
    for (const auto& s : c.sockets)
        sockets.push_back(EditorValue::Object{
            {"direction", directionName(s.direction)}, {"type", s.type}, {"accepts", strings(s.accepts)}});
    return EditorValue::Object{{"editorId", value.id.value()},
                               {"id", c.id},
                               {"model", c.modelPath},
                               {"category", c.category},
                               {"width", int64_t{c.width}},
                               {"depth", int64_t{c.depth}},
                               {"height", int64_t{c.height}},
                               {"weight", int64_t{c.weight}},
                               {"rotations", integers(c.rotations)},
                               {"tags", strings(c.tags)},
                               {"sockets", std::move(sockets)},
                               {"material", materialValue(c.material)}};
}
bool number(const EditorValue* value, float& out) {
    const auto* n = value ? value->getIf<double>() : nullptr;
    if (!n || !std::isfinite(*n)) return false;
    out = static_cast<float>(*n);
    return true;
}
Result<HouseKitComponentValue> parseComponent(const EditorValue& value) {
    HouseKitComponentValue out;
    const auto *editorId = field(value, "editorId"), *id = field(value, "id"), *model = field(value, "model"),
               *category   = field(value, "category");
    const auto* editorIds  = editorId ? editorId->getIf<std::string>() : nullptr;
    const auto* ids        = id ? id->getIf<std::string>() : nullptr;
    const auto* models     = model ? model->getIf<std::string>() : nullptr;
    const auto* categories = category ? category->getIf<std::string>() : nullptr;
    if (!editorIds || editorIds->empty() || !ids || !models || !categories)
        return eve::editing::failed<HouseKitComponentValue>(EditorStatus::Rejected, RuleId("editor.housegen.component"),
                                                            "House component identity is invalid");
    out.id                  = ObjectId(*editorIds);
    out.component.id        = *ids;
    out.component.modelPath = *models;
    out.component.category  = *categories;
    int*        values[] = {&out.component.width, &out.component.depth, &out.component.height, &out.component.weight};
    const char* fields[] = {"width", "depth", "height", "weight"};
    for (int i = 0; i < 4; ++i) {
        const auto* v = field(value, fields[i]);
        const auto* n = v ? v->getIf<int64_t>() : nullptr;
        if (!n)
            return eve::editing::failed<HouseKitComponentValue>(
                EditorStatus::Rejected, RuleId("editor.housegen.dimension"), "House component dimension is invalid");
        *values[i] = static_cast<int>(*n);
    }
    if (!readIntegers(field(value, "rotations"), out.component.rotations) ||
        !readStrings(field(value, "tags"), out.component.tags))
        return eve::editing::failed<HouseKitComponentValue>(EditorStatus::Rejected, RuleId("editor.housegen.arrays"),
                                                            "House component rotations or tags are invalid");
    const auto* socketValues = field(value, "sockets");
    const auto* socketArray  = socketValues ? socketValues->getIf<EditorValue::Array>() : nullptr;
    if (!socketArray)
        return eve::editing::failed<HouseKitComponentValue>(EditorStatus::Rejected, RuleId("editor.housegen.sockets"),
                                                            "House sockets are invalid");
    for (const auto& socketValue : *socketArray) {
        housegen::HouseSocket socket;
        const auto *          d = field(socketValue, "direction"), *t = field(socketValue, "type");
        const auto*           ds = d ? d->getIf<std::string>() : nullptr;
        const auto*           ts = t ? t->getIf<std::string>() : nullptr;
        if (!ds || !ts || !direction(*ds, socket.direction) ||
            !readStrings(field(socketValue, "accepts"), socket.accepts))
            return eve::editing::failed<HouseKitComponentValue>(
                EditorStatus::Rejected, RuleId("editor.housegen.socket"), "House socket is invalid");
        socket.type = *ts;
        out.component.sockets.push_back(std::move(socket));
    }
    const auto* material = field(value, "material");
    if (!material)
        return eve::editing::failed<HouseKitComponentValue>(EditorStatus::Rejected, RuleId("editor.housegen.material"),
                                                            "House material is missing");
    auto&       m   = out.component.material;
    const auto *hbc = field(*material, "hasBaseColor"), *hm = field(*material, "hasMetallic"),
               *hr         = field(*material, "hasRoughness");
    const auto* hbcb       = hbc ? hbc->getIf<bool>() : nullptr;
    const auto* hmb        = hm ? hm->getIf<bool>() : nullptr;
    const auto* hrb        = hr ? hr->getIf<bool>() : nullptr;
    const auto* colorValue = field(*material, "baseColor");
    const auto* color      = colorValue ? colorValue->getIf<EditorValue::Array>() : nullptr;
    if (!hbcb || !hmb || !hrb || !color || color->size() != 4)
        return eve::editing::failed<HouseKitComponentValue>(EditorStatus::Rejected, RuleId("editor.housegen.material"),
                                                            "House material flags or color are invalid");
    m.hasBaseColor  = *hbcb;
    m.hasMetallic   = *hmb;
    m.hasRoughness  = *hrb;
    float* colors[] = {&m.baseColorR, &m.baseColorG, &m.baseColorB, &m.baseColorA};
    for (int i = 0; i < 4; ++i)
        if (!number(&(*color)[i], *colors[i]))
            return eve::editing::failed<HouseKitComponentValue>(EditorStatus::Rejected, RuleId("editor.housegen.color"),
                                                                "House material color is invalid");
    std::string* paths[]      = {&m.baseColorTexture, &m.normalTexture, &m.heightTexture};
    const char*  pathFields[] = {"baseColorTexture", "normalTexture", "heightTexture"};
    for (int i = 0; i < 3; ++i) {
        const auto* p = field(*material, pathFields[i]);
        const auto* s = p ? p->getIf<std::string>() : nullptr;
        if (!s)
            return eve::editing::failed<HouseKitComponentValue>(
                EditorStatus::Rejected, RuleId("editor.housegen.texture"), "House material texture is invalid");
        *paths[i] = *s;
    }
    float*      scalars[]      = {&m.metallic,          &m.roughness,     &m.parallaxScale,    &m.parallaxMinLayers,
                                  &m.parallaxMaxLayers, &m.cellBombScale, &m.cellBombStrength, &m.cellBombRotation};
    const char* scalarFields[] = {"metallic",          "roughness",     "parallaxScale",    "parallaxMinLayers",
                                  "parallaxMaxLayers", "cellBombScale", "cellBombStrength", "cellBombRotation"};
    for (int i = 0; i < 8; ++i)
        if (!number(field(*material, scalarFields[i]), *scalars[i]))
            return eve::editing::failed<HouseKitComponentValue>(
                EditorStatus::Rejected, RuleId("editor.housegen.material-number"), "House material number is invalid");
    return eve::editing::applied<HouseKitComponentValue>(std::move(out));
}
EditorValue requestValue(const housegen::HouseRequest& r) {
    return EditorValue::Object{{"seed", int64_t{r.seed}},
                               {"width", int64_t{r.width}},
                               {"depth", int64_t{r.depth}},
                               {"floors", int64_t{r.floors}},
                               {"moduleSize", r.moduleSize},
                               {"floorHeight", r.floorHeight},
                               {"style", r.style},
                               {"footprint", r.footprint},
                               {"roof", r.roof},
                               {"entrance", r.entrance},
                               {"requiredRooms", strings(r.requiredRooms)},
                               {"maxAttempts", int64_t{r.maxAttempts}}};
}
Result<housegen::HouseRequest> parseRequest(const EditorValue& value) {
    housegen::HouseRequest r;
    uint32_t*              unused = nullptr;
    (void)unused;
    const auto* seed  = field(value, "seed");
    const auto* seedn = seed ? seed->getIf<int64_t>() : nullptr;
    if (!seedn || *seedn < 0 || *seedn > UINT32_MAX)
        return eve::editing::failed<housegen::HouseRequest>(EditorStatus::Rejected, RuleId("editor.housegen.seed"),
                                                            "House seed is invalid");
    r.seed                  = static_cast<uint32_t>(*seedn);
    int*        ints[]      = {&r.width, &r.depth, &r.floors, &r.maxAttempts};
    const char* intFields[] = {"width", "depth", "floors", "maxAttempts"};
    for (int i = 0; i < 4; ++i) {
        const auto* v = field(value, intFields[i]);
        const auto* n = v ? v->getIf<int64_t>() : nullptr;
        if (!n)
            return eve::editing::failed<housegen::HouseRequest>(
                EditorStatus::Rejected, RuleId("editor.housegen.request-number"), "House request integer is invalid");
        *ints[i] = static_cast<int>(*n);
    }
    if (!number(field(value, "moduleSize"), r.moduleSize) || !number(field(value, "floorHeight"), r.floorHeight))
        return eve::editing::failed<housegen::HouseRequest>(
            EditorStatus::Rejected, RuleId("editor.housegen.request-number"), "House request scale is invalid");
    std::string* values[] = {&r.style, &r.footprint, &r.roof, &r.entrance};
    const char*  fields[] = {"style", "footprint", "roof", "entrance"};
    for (int i = 0; i < 4; ++i) {
        const auto* v = field(value, fields[i]);
        const auto* s = v ? v->getIf<std::string>() : nullptr;
        if (!s)
            return eve::editing::failed<housegen::HouseRequest>(
                EditorStatus::Rejected, RuleId("editor.housegen.request-string"), "House request string is invalid");
        *values[i] = *s;
    }
    if (!readStrings(field(value, "requiredRooms"), r.requiredRooms))
        return eve::editing::failed<housegen::HouseRequest>(EditorStatus::Rejected, RuleId("editor.housegen.rooms"),
                                                            "Required rooms are invalid");
    return eve::editing::applied<housegen::HouseRequest>(std::move(r));
}
PropertyDescriptor prop(std::string path, PropertyType type, EditorValue defaultValue, double minimum = -1e9,
                        double maximum = 1e9) {
    PropertyDescriptor d;
    d.path            = PropertyPath(path);
    d.displayNameKey  = "editor.housegen." + path;
    d.category        = "component";
    d.type            = type;
    d.defaultValue    = std::move(defaultValue);
    d.flags           = PropertyFlag::EditorOnly;
    d.numeric.minimum = minimum;
    d.numeric.maximum = maximum;
    return d;
}
bool hasErrors(const std::vector<EditorDiagnostic>& values) {
    return std::any_of(values.begin(), values.end(),
                       [](const auto& d) { return d.severity() == DiagnosticSeverity::Error; });
}
}  // namespace
 
HouseGenDocumentTarget::HouseGenDocumentTarget(std::string id) : id_(std::move(id)) {}
TargetDescriptor HouseGenDocumentTarget::describe() const {
    return {TargetId(id_),
            "housegen-asset",
            revisionValue(),
            false,
            {CapabilityId("eve.editor.target.housegen-properties")}};
}
void* HouseGenDocumentTarget::queryCapability(const CapabilityId& c) {
    return c == CapabilityId("eve.editor.target.housegen-properties") ? static_cast<IPropertyProvider*>(this) : nullptr;
}
bool HouseGenDocumentTarget::matches(const SelectionSnapshot& s) const {
    if (s.items.empty()) return false;
    for (const auto& item : s.items)
        if (item.target != TargetId(id_) || std::none_of(components_.begin(), components_.end(), [&](const auto& c) {
                return c.id.value() == item.item.value();
            }))
            return false;
    return true;
}
eve::Result<eve::Revision> HouseGenDocumentTarget::currentRevision(const SelectionSnapshot& s) const {
    if (!matches(s))
        return eve::Result<eve::Revision>::failure(eve::Diagnostic::error(
            eve::DiagnosticCode::InvalidArgument, "House component selection mismatch", "editor.housegen.selection"));
    return eve::Result<eve::Revision>::success(eve::Revision(revisionValue()));
}
PropertySchema HouseGenDocumentTarget::schema(const SelectionSnapshot&) const {
    PropertySchema s;
    s.typeId                         = "housegen.component";
    s.properties                     = {prop("component.model", PropertyType::AssetRef, ""),
                                        prop("component.category", PropertyType::Enum, "wall"),
                                        prop("component.width", PropertyType::Int, int64_t{1}, 1, 128),
                                        prop("component.depth", PropertyType::Int, int64_t{1}, 1, 128),
                                        prop("component.height", PropertyType::Int, int64_t{1}, 1, 128),
                                        prop("component.weight", PropertyType::Int, int64_t{1}, 1, 100000),
                                        prop("material.metallic", PropertyType::Float, 0.0, 0, 1),
                                        prop("material.roughness", PropertyType::Float, 1.0, 0, 1)};
    s.properties[0].assetTypeFilters = {"model3d"};
    s.properties[1].enumItems        = {"foundation", "floor", "wall", "door", "roof"};
    return s;
}
PropertyReadResult HouseGenDocumentTarget::read(const SelectionSnapshot& s, const PropertyPath& path) const {
    if (!matches(s) || !schema(s).find(path)) return {};
    std::optional<EditorValue> common;
    for (const auto& item : s.items) {
        const auto& c = std::find_if(components_.begin(), components_.end(), [&](const auto& v) {
                            return v.id.value() == item.item.value();
                        })->component;
        EditorValue value;
        if (path == PropertyPath("component.model"))
            value = c.modelPath;
        else if (path == PropertyPath("component.category"))
            value = c.category;
        else if (path == PropertyPath("component.width"))
            value = int64_t{c.width};
        else if (path == PropertyPath("component.depth"))
            value = int64_t{c.depth};
        else if (path == PropertyPath("component.height"))
            value = int64_t{c.height};
        else if (path == PropertyPath("component.weight"))
            value = int64_t{c.weight};
        else if (path == PropertyPath("material.metallic"))
            value = static_cast<double>(c.material.metallic);
        else
            value = static_cast<double>(c.material.roughness);
        if (!common)
            common = value;
        else if (*common != value)
            return {PropertyReadState::Mixed, {}, {}};
    }
    return {PropertyReadState::Value, *common, {}};
}
EditorValue HouseGenDocumentTarget::contentValue() const {
    EditorValue::Array components;
    for (const auto& c : components_) components.push_back(componentValue(c));
    return EditorValue::Object{{"components", std::move(components)}, {"request", requestValue(request_)}};
}
Result<DomainOperation> HouseGenDocumentTarget::replacement(EditorValue content,
                                                                   std::string property) const {
    DomainOperation op;
    op.type        = "housegen.document.replace.v1";
    op.inverseType = op.type;
    op.target      = TargetId(id_);
    op.payload     = std::move(content);
    op.inverse     = contentValue();
    op.hasInverse  = true;
    if (!property.empty()) op.affectedProperties.push_back(property);
    op.mergeKey = "housegen:" + id_ + ":" + (property.empty() ? "structure" : property);
    return eve::editing::applied<DomainOperation>(std::move(op));
}
Result<DomainOperation> HouseGenDocumentTarget::makeSet(const SelectionSnapshot& s, const PropertyPath& path,
                                                              const EditorValue& value, PropertySetMode mode) const {
    if (mode == PropertySetMode::Reset) return makeReset(s, path);
    auto d = schema(s).find(path);
    if (!matches(s) || !d || mode != PropertySetMode::Absolute || !validatePropertyValue(*d, value).ok())
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.housegen.set"),
                                                     "House component property is invalid");
    auto candidate = *this;
    for (const auto& item : s.items) {
        auto& c = std::find_if(candidate.components_.begin(), candidate.components_.end(), [&](const auto& v) {
                      return v.id.value() == item.item.value();
                  })->component;
        if (path == PropertyPath("component.model"))
            c.modelPath = *value.getIf<std::string>();
        else if (path == PropertyPath("component.category"))
            c.category = *value.getIf<std::string>();
        else if (path == PropertyPath("component.width"))
            c.width = static_cast<int>(*value.getIf<int64_t>());
        else if (path == PropertyPath("component.depth"))
            c.depth = static_cast<int>(*value.getIf<int64_t>());
        else if (path == PropertyPath("component.height"))
            c.height = static_cast<int>(*value.getIf<int64_t>());
        else if (path == PropertyPath("component.weight"))
            c.weight = static_cast<int>(*value.getIf<int64_t>());
        else if (path == PropertyPath("material.metallic")) {
            c.material.hasMetallic = true;
            c.material.metallic    = static_cast<float>(*value.getIf<double>());
        } else {
            c.material.hasRoughness = true;
            c.material.roughness    = static_cast<float>(*value.getIf<double>());
        }
    }
    if (hasErrors(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.housegen.invalid"),
                                                     "House component edit invalidates the kit");
    return replacement(candidate.contentValue(), path.value());
}
Result<DomainOperation> HouseGenDocumentTarget::makeReset(const SelectionSnapshot& s,
                                                                const PropertyPath&      path) const {
    auto d = schema(s).find(path);
    if (!d)
        return eve::editing::failed<DomainOperation>(EditorStatus::Unsupported, RuleId("editor.housegen.property"),
                                                     "Unknown house component property");
    return makeSet(s, path, d->defaultValue, PropertySetMode::Absolute);
}
Result<DomainOperation> HouseGenDocumentTarget::makeCreateComponent(
    const HouseKitComponentValue& component) const {
    if (component.id.empty() || std::any_of(components_.begin(), components_.end(), [&](const auto& c) {
            return c.id == component.id || c.component.id == component.component.id;
        }))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.housegen.component-id"),
                                                     "House editor and runtime component IDs must be unique");
    auto candidate = *this;
    candidate.components_.push_back(component);
    housegen::HouseComponentLibrary library;
    if (!library.registerComponent(component.component).ok())
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.housegen.component"),
                                                     "House runtime rejected the component");
    return replacement(candidate.contentValue());
}
Result<DomainOperation> HouseGenDocumentTarget::makeDeleteComponent(const ObjectId& id) const {
    if (std::none_of(components_.begin(), components_.end(), [&](const auto& c) { return c.id == id; }))
        return eve::editing::failed<DomainOperation>(EditorStatus::NotFound, RuleId("editor.housegen.component"),
                                                     "House component does not exist");
    auto candidate = *this;
    std::erase_if(candidate.components_, [&](const auto& c) { return c.id == id; });
    return replacement(candidate.contentValue());
}
Result<DomainOperation> HouseGenDocumentTarget::makeSetRequest(const housegen::HouseRequest& request) const {
    auto candidate     = *this;
    candidate.request_ = request;
    if (hasErrors(candidate.validate()))
        return eve::editing::failed<DomainOperation>(EditorStatus::Rejected, RuleId("editor.housegen.request"),
                                                     "House generation request is invalid");
    return replacement(candidate.contentValue(), "request");
}
std::vector<EditorDiagnostic> HouseGenDocumentTarget::validate() const {
    std::vector<EditorDiagnostic> out;
    if (components_.size() > 2048)
        out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.housegen.component-budget"), DiagnosticSeverity::Error,
            "House kit exceeds 2048 components"));
    housegen::HouseComponentLibrary library;
    std::set<std::string>           editorIds;
    std::set<std::string>           categories;
    for (const auto& c : components_) {
        if (c.id.empty() || !editorIds.insert(c.id.value()).second)
            out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::Conflict,
                RuleId("editor.housegen.editor-id"), DiagnosticSeverity::Error,
                "House editor component IDs must be unique"));
        auto registered = library.registerComponent(c.component);
        if (!registered.ok())
            out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
                RuleId("editor.housegen.component"), DiagnosticSeverity::Error,
                "Invalid or duplicate runtime component: " + c.component.id));
        categories.insert(c.component.category);
    }
    for (const char* required : {"foundation", "floor", "wall", "door", "roof"})
        if (!categories.contains(required))
            out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
                RuleId("editor.housegen.category"), DiagnosticSeverity::Warning,
                "House kit is not generation-ready; missing category: " + std::string(required)));
    const bool footprint = request_.footprint == "auto" || request_.footprint == "rectangle" ||
                           request_.footprint == "l_shape" || request_.footprint == "t_shape";
    const bool roof =
        request_.roof == "auto" || request_.roof == "gable" || request_.roof == "flat" || request_.roof == "shed";
    const bool entrance = request_.entrance == "auto" || request_.entrance == "north" || request_.entrance == "east" ||
                          request_.entrance == "south" || request_.entrance == "west";
    if (request_.width < 2 || request_.width > 256 || request_.depth < 2 || request_.depth > 256 ||
        request_.floors < 1 || request_.floors > 64 || !std::isfinite(request_.moduleSize) ||
        request_.moduleSize <= 0 || request_.moduleSize > 10000 || !std::isfinite(request_.floorHeight) ||
        request_.floorHeight <= 0 || request_.floorHeight > 10000 || request_.maxAttempts < 1 ||
        request_.maxAttempts > 10000 || !footprint || !roof || !entrance)
        out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::InvalidArgument,
            RuleId("editor.housegen.request-range"), DiagnosticSeverity::Error,
            "House generation request exceeds supported values or budgets"));
    if (request_.requiredRooms.size() > 256)
        out.push_back(eve::editing::ruleDiagnostic(eve::DiagnosticCode::PreconditionViolation,
            RuleId("editor.housegen.room-budget"), DiagnosticSeverity::Error,
            "House request exceeds 256 required rooms"));
    return out;
}
Result<void> HouseGenDocumentTarget::applyDomainOperation(const DomainOperation& op) {
    if (op.target != TargetId(id_) || op.type != "housegen.document.replace.v1")
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.housegen.operation"),
                                          "House operation mismatch");
    const auto *componentsValue = field(op.payload, "components"), *requestValueField = field(op.payload, "request");
    const auto* components = componentsValue ? componentsValue->getIf<EditorValue::Array>() : nullptr;
    if (!components || !requestValueField || components->size() > 2048 ||
        !op.payload.isWithinLimits(10, 200000, 16 * 1024 * 1024))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.housegen.payload"),
                                          "House document payload exceeds limits");
    HouseGenDocumentTarget candidate(id_);
    for (const auto& value : *components) {
        auto parsed = parseComponent(value);
        if (!parsed.ok())
            return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.housegen.component"),
                                              "House document component cannot be parsed");
        candidate.components_.push_back(parsed.value());
    }
    auto request = parseRequest(*requestValueField);
    if (!request.ok())
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.housegen.request"),
                                          "House document request cannot be parsed");
    candidate.request_ = request.value();
    if (hasErrors(candidate.validate()))
        return eve::editing::failed<void>(EditorStatus::Rejected, RuleId("editor.housegen.invalid"),
                                          "House document validation failed");
    components_ = std::move(candidate.components_);
    request_    = std::move(candidate.request_);
    bumpRevision();
    widenDirty(0, 0);
    return eve::editing::applied<void>();
}
std::unique_ptr<IDomainOperationTarget> HouseGenDocumentTarget::cloneDomainState() const {
    return std::make_unique<HouseGenDocumentTarget>(*this);
}
Result<void> HouseGenDocumentTarget::commitDomainState(
    std::unique_ptr<IDomainOperationTarget> candidate) {
    auto* typed = dynamic_cast<HouseGenDocumentTarget*>(candidate.get());
    if (!typed || typed->id_ != id_)
        return eve::editing::failed<void>(EditorStatus::Conflict, RuleId("editor.housegen.candidate"),
                                          "House candidate mismatch");
    *this = *typed;
    return eve::editing::applied<void>();
}
EditorValue HouseGenDocumentTarget::snapshotValue() const {
    return EditorValue::Object{{"schemaVersion", int64_t{1}}, {"content", contentValue()}};
}
Result<void> HouseGenDocumentTarget::loadSnapshot(const EditorValue& snapshot) {
    const auto *versionValue = field(snapshot, "schemaVersion"), *content = field(snapshot, "content");
    const auto* version = versionValue ? versionValue->getIf<int64_t>() : nullptr;
    if (!version || *version != 1 || !content)
        return eve::editing::failed<void>(EditorStatus::Unsupported, RuleId("editor.housegen.snapshot"),
                                          "Unsupported house snapshot");
    DomainOperation op;
    op.target   = TargetId(id_);
    op.type     = "housegen.document.replace.v1";
    op.payload  = *content;
    auto result = applyDomainOperation(op);
    if (result.ok()) clearDirtyRegion();
    return result;
}
 
}  // namespace eve::housegen_editing