Factory

The Factory subsystem defines the core factory abstraction for the Scriptable Factory system. It provides a three-tier hierarchy of interfaces and abstract classes that handle object lifecycle (instantiate, spawn, despawn, destroy), object pooling, and data-driven variant spawning.

Architecture

Key Concepts

Concept	Description
Three-tier hierarchy	Each tier adds capability: base (lifecycle) → single-generic (pooling) → double-generic (data + variants).
Object pooling	ScriptableFactory<TObject> manages a FactorablePool for efficient spawn/despawn without allocation.
Data variants	ScriptableFactory<TObject, TData> supports a DataVariantSystem with DataOverride for spawning objects with different configurations from the same factory.
ScriptableObject-based	Factories are ScriptableObject assets, configured in the Inspector and discovered by the ScriptableFactoryRegistry.
IFactorable contract	All spawned objects must implement IFactorable (or IFactorable<TData> for data-driven objects).

Object Lifecycle

Quick Start

Creating a Simple Factory (No Data)

using System;
using Paragon.Core.ScriptableFactory;
using UnityEngine;

[Serializable]
[CreateAssetMenu(menuName = "Factories/Effect Factory")]
public class EffectFactory : ScriptableFactory<EffectObject>
{
    [SerializeField] private GameObject prefab;

    protected override EffectObject InstantiateObject()
    {
        var go = Instantiate(prefab, transform);
        return go.GetComponent<EffectObject>();
    }
}

Creating a Data-Driven Factory

using System;
using Paragon.Core.ScriptableFactory;
using UnityEngine;

[Serializable]
[CreateAssetMenu(menuName = "Factories/Enemy Factory")]
public class EnemyFactory : ScriptableFactory<Enemy, EnemyData>
{
    [SerializeField] private GameObject prefab;

    protected override Enemy InstantiateObject()
    {
        var go = Instantiate(prefab, transform);
        return go.GetComponent<Enemy>();
    }
}

Spawning Objects

// Simple spawn (no data)
EffectObject effect = effectFactory.Spawn();

// Data-driven spawn (default data)
Enemy enemy = enemyFactory.Spawn();

// Spawn with variant
Enemy variant = enemyFactory.Spawn(variantID: 1);

// Spawn with override
var over = new DataOverride(typeof(EnemyData));
over.AddFieldOverride("maxHealth", 200f);
Enemy custom = enemyFactory.Spawn(dataOverride: over);

// Return to pool
effectFactory.Despawn(effect);
enemyFactory.Despawn(enemy);

Classes

Class	Description
IScriptableFactory	Interface hierarchy defining the factory contract
ScriptableFactory	Abstract base — lifecycle and GameObject management
ScriptableFactory<TObject>	Single-generic — pooling, spawn/despawn, lifecycle hooks
ScriptableFactory<TObject, TData>	Double-generic — data variants, data-driven spawning

See Also

• Scriptable Factory System — parent system overview

• FactorableData — data record base class

• ScriptableFactoryRegistry — factory discovery and lookup

• ScriptableFactoryManager — runtime lifecycle management