punkfuncgames/patterns

Architecture Patterns Reference

Config + Data Pattern (Mandatory)

All ScriptableObject configs follow Data-Oriented Design:

Config SO — thin wrapper:

[CreateAssetMenu(menuName = "GameTemplate/My Config")]
public sealed class MyConfig : ScriptableObject
{
    public MyConfigData data;

    private void OnValidate()
    {
        // Editor-time validation only
    }
}

Data struct — pure data, no methods, no logic:

[Serializable]
public struct MyConfigData
{
    public float duration;
    public int maxCount;
    public Color defaultColor;
}

Extension methods — logic lives here:

public static class MyConfigDataExtensions
{
    public static bool IsValid(this MyConfigData data)
    {
        return data.duration > 0f && data.maxCount > 0;
    }
}

Access pattern: _config.data.fieldName (never _config.PropertyName)

Testing: Create Data structs directly via ScriptableObject.CreateInstance<T>() + struct initializer. No CreateRuntime() factories.

Service Pattern

Services implement domain logic. They are pure C# classes with constructor injection.

public sealed class MyService : IMyService, IAsyncStartable, ITickable, IDisposable
{
    private readonly IDependency _dep;
    private readonly IPublisher<MyEvent> _publisher;
    private readonly CompositeDisposable _disposables = new();

    public MyService(IDependency dep, IPublisher<MyEvent> publisher)
    {
        _dep = dep ?? throw new ArgumentNullException(nameof(dep));
        _publisher = publisher ?? throw new ArgumentNullException(nameof(publisher));
    }

    public async UniTask StartAsync(CancellationToken ct)
    {
        // Initialization logic
    }

    public void Tick()
    {
        // Per-frame logic (if ITickable)
    }

    public void Dispose()
    {
        _disposables.Dispose();
    }
}

Key patterns:

• Constructor null guards with ArgumentNullException
• IAsyncStartable for async initialization (VContainer auto-calls)
• ITickable for per-frame logic (replaces Update())
• IDisposable with CompositeDisposable for cleanup
• Nullable ILogService (optional dependency)

Installer Pattern

Installers register services and MessagePipe brokers in LifetimeScope.Configure().

public static class MyInstaller
{
    public static void Install(IContainerBuilder builder, MessagePipeOptions options, MyConfig config = null)
    {
        builder.RegisterEntryPoint<MyService>()
            .As<IMyService>();

        if (config)
        {
            builder.RegisterInstance(config);
        }

        builder.RegisterMessageBroker<MyEvent>(options);
        builder.RegisterMessageBroker<MyOtherEvent>(options);
    }
}

Key patterns:

• Static Install method with IContainerBuilder + MessagePipeOptions
• Optional config parameter (null-safe with implicit bool check)
• RegisterEntryPoint for services with IAsyncStartable/ITickable
• .As<IInterface>() for interface registration

MessagePipe Event Pattern

Events are readonly structs published via MessagePipe brokers.

public readonly struct MyEvent
{
    public string Id { get; }
    public int Value { get; }

    public MyEvent(string id, int value)
    {
        Id = id;
        Value = value;
    }
}

Publishing:

_publisher.Publish(new MyEvent("item1", 42));

Subscribing:

_subscriber.Subscribe(e => HandleEvent(e)).AddTo(_disposables);

Converting to Observable (R3):

_subscriber.AsObservable()
    .Where(e => e.Value > 0)
    .Subscribe(e => HandleEvent(e))
    .AddTo(_disposables);

Reactive Disposal Pattern

Pure C# classes:

public sealed class MyClass : IDisposable
{
    private readonly CompositeDisposable _disposables = new();

    public void Setup()
    {
        _property.Subscribe(OnChanged).AddTo(_disposables);
    }

    public void Dispose()
    {
        _disposables.Dispose();
    }
}

MonoBehaviours:

public sealed class MyView : MonoBehaviour
{
    private void Start()
    {
        _property.Subscribe(OnChanged).AddTo(this);
    }
}