ScriptableFactory

A type-safe object pooling and factory system built on ScriptableObjects.

Overview

ScriptableFactory provides:

• Object Pooling — Automatic instantiation and reuse of objects

• Type Safety — Generic factories with compile-time type checking

• Data-Driven Design — Configure factories via ScriptableObjects

• Variant System — Create data variants with overridable fields

• Lifecycle Management — Spawn, despawn, and destroy with proper callbacks

Architecture

┌─────────────────────────────────────────────────────────────┐
│               ScriptableFactoryManager (Singleton)          │
│                    Manages all factories                     │
└───────────────────────────┬─────────────────────────────────┘
                            │ registers
                            ▼
┌─────────────────────────────────────────────────────────────┐
│                   ScriptableFactoryRegistry                  │
│               (Static database of factories)                 │
└───────────────────────────┬─────────────────────────────────┘
                            │ contains
                            ▼
┌─────────────────────────────────────────────────────────────┐
│              ScriptableFactory<TObject, TData>               │
│                   (Abstract factory base)                    │
│                           │                                  │
│    ┌──────────────────────┼──────────────────────┐          │
│    ▼                      ▼                      ▼          │
│ FactorablePool    DataVariantSystem      DataOverride       │
└───────────────────────────┬─────────────────────────────────┘
                            │ creates
                            ▼
┌─────────────────────────────────────────────────────────────┐
│  FactorableBehaviour / FactorableObject / FactorableScriptableObject  │
│                   (Poolable objects with data)               │
└─────────────────────────────────────────────────────────────┘

Quick Start

Creating a Factory

[CreateAssetMenu(menuName = "Factories/Enemy Factory")]
public class EnemyFactory : ScriptableFactory<Enemy, EnemyData>
{
    public GameObject enemyPrefab;
    
    protected override Enemy InstantiateObject()
    {
        var go = Instantiate(enemyPrefab, transform);
        return go.GetComponent<Enemy>();
    }
}

Creating a Poolable Object

public class Enemy : FactorableBehaviour<EnemyData>
{
    protected override void InitializeData(EnemyData data)
    {
        health = data.health;
        speed = data.speed;
    }
    
    protected override void OnSpawn()
    {
        // Called when object is taken from pool
    }
}

Using the Factory

// Spawn from pool with default data
Enemy enemy = enemyFactory.Spawn();

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

// Spawn with override
var override = new DataOverride(typeof(EnemyData));
override.AddFieldOverride("health", 500);
Enemy boss = enemyFactory.Spawn(0, override);

// Return to pool
enemy.Despawn();

API Reference

Core

• IScriptableFactory

• ScriptableFactory

• ScriptableFactory<T>

• ScriptableFactory<TObject, TData>

• ScriptableFactoryManager

• ScriptableFactoryRegistry

• ScriptableFactoryDatabase

• ScriptableFactoryMonitor

Objects

• IFactorable

• FactorableBehaviour

• FactorableObject

• FactorableScriptableObject

• FactorableData

• FactorableDataUtility

Pool

• FactorablePool

Spawner

• FactorableSpawner

Variant System

• DataVariantSystem

• DataOverride

• DataFieldOverride

• OverridableAttribute

Editor

• Editor Support