OverridableAttribute

Field-level attribute that marks a FactorableData field as eligible for override by the variant system. Extends OdinSerializeAttribute to ensure the marked field is also Odin-serialized.

Definition

Namespace: Paragon.Core.ScriptableFactory Assembly: Paragon.dll

[AttributeUsage(AttributeTargets.Field)]
public class OverridableAttribute : OdinSerializeAttribute

Inherits: Sirenix.Serialization.OdinSerializeAttribute

Remarks

This attribute serves a dual purpose:

1. Variant eligibility — DataOverride.CanOverrideField() checks for this attribute via reflection. Fields without [Overridable] are rejected when adding field overrides.

2. Odin serialization — Inheriting from OdinSerializeAttribute ensures marked fields are serialized by Odin, even if they would not be serialized by Unity's default serializer.

An optional OverriderType parameter allows specifying a custom DataFieldOverride subclass for fields that need specialized override logic (e.g., list merging, conditional application).

Quick Lookup

Goal	How
Mark a field as overridable	[Overridable] public float health;
Use a custom overrider	[Overridable(typeof(MyCustomOverride))] public List<Item> items;
Check if a field is overridable	DataOverride.CanOverrideField(fieldName)

Properties

OverriderType

Optional custom DataFieldOverride subclass type used instead of the default DataFieldOverride<TField>.

public readonly Type OverriderType;

When null (default), the system auto-creates DataFieldOverride<TField> using the field's type. When set, the system creates an instance of the specified type instead.

Constructor

public OverridableAttribute(Type overriderType = default)

Parameter	Type	Description
overriderType	Type	Custom DataFieldOverride subclass type, or null for default behavior

Usage Examples

Basic usage

[Serializable]
public record EnemyData : FactorableData
{
    [Overridable]
    public float health = 100f;

    [Overridable]
    public float speed = 3f;

    [Overridable]
    public GameObject prefab;

    // This field CANNOT be overridden
    public string internalTag = "enemy";
}

Custom overrider type

// Custom override that merges lists instead of replacing
public class ItemListOverride : DataFieldOverride
{
    public override object Apply(object target)
    {
        // Custom merge logic
        FieldInfo field = GetField(target, fieldName);
        var existing = (List<Item>)field.GetValue(target);
        existing.AddRange((List<Item>)value);
        return existing;
    }
}

[Serializable]
public record LootTableData : FactorableData
{
    [Overridable(typeof(ItemListOverride))]
    public List<Item> items;
}

Common Pitfalls

Only works on fields, not properties [AttributeUsage(AttributeTargets.Field)] restricts this attribute to fields only. Applying it to a property will compile but will not be discovered by DataOverride.GetOverridableFields(), which uses GetFields().

Custom overrider must extend DataFieldOverride The OverriderType must be a class with a constructor matching (string fieldName, object fieldValue). The system creates instances via Activator.CreateInstance(overriderType, fieldName, fieldValue).

See Also

• DataOverride — uses this attribute to discover overridable fields

• DataFieldOverride — base class for override instances

• FactorableData — base record class whose fields are marked