InteractionTrigger

Abstract base class for interaction triggers. Determines how an interaction can be initiated by matching against an incoming trigger instance. The generic variant InteractionTrigger<T> provides a type-safe matching pattern.

Definition

Namespace: Paragon.Townskeep.InteractionSystem Assembly: Townskeep.dll

[Serializable]
public abstract class InteractionTrigger

[Serializable]
public abstract class InteractionTrigger<TInteractionTrigger> : InteractionTrigger
    where TInteractionTrigger : InteractionTrigger

Remarks

The trigger system uses a two-level pattern:

1. InteractionTrigger (non-generic) — base class with Initialize() and the abstract Match() method.

2. InteractionTrigger<T> (generic) — implements Match() with type checking, then delegates to IsMatch(T).

This means concrete triggers only need to implement IsMatch(T), and the type dispatching is handled automatically.

Triggers are stored as a list on InteractionContext and matched via InteractionContext.CanBeTriggeredWith().

Quick Lookup

Goal	How
Create a custom trigger	Subclass InteractionTrigger<YourTrigger>, override IsMatch()
Match against a trigger	trigger.Match(incomingTrigger)
Access parent context	this.context (protected field)

Methods

Initialize

Initializes the trigger with its owning context. Called by InteractionContext.Initialize().

public void Initialize(InteractionContext context)

Parameter	Type	Description
context	InteractionContext	The owning context

Match (abstract, non-generic)

Tests whether this trigger matches the given incoming trigger.

public abstract bool Match(InteractionTrigger trigger)

Parameter	Type	Description
trigger	InteractionTrigger	The incoming trigger to match against

Returns: true if the triggers match.

Match (generic override)

The generic variant implements Match() by first type-checking the incoming trigger, then delegating to IsMatch().

// In InteractionTrigger<TInteractionTrigger>
public override bool Match(InteractionTrigger trigger)
{
    return trigger is TInteractionTrigger tTrigger && IsMatch(tTrigger);
}

IsMatch (abstract, generic)

Performs the actual comparison logic between two triggers of the same type.

protected abstract bool IsMatch(TInteractionTrigger trigger)

Parameter	Type	Description
trigger	TInteractionTrigger	The typed trigger to compare against

Returns: true if the triggers are considered a match.

Extension Points

Required Overrides (non-generic path)

Method	Purpose
Match(InteractionTrigger)	Full match logic including type checking

Required Overrides (generic path — recommended)

Method	Purpose
IsMatch(T)	Type-safe comparison logic

Prefer the generic path. Subclass InteractionTrigger<YourTrigger> instead of the non-generic InteractionTrigger to get automatic type dispatching.

Implementation Requirements

When creating a custom trigger, you MUST:

1. Subclass InteractionTrigger<YourTrigger> (recommended) or InteractionTrigger

2. Mark the class with [Serializable]

3. Implement IsMatch(YourTrigger) (generic) or Match(InteractionTrigger) (non-generic)

You SHOULD:

• Define serializable fields for match criteria (e.g., key codes, zone IDs)

• Keep matching logic fast — it is called during interaction queries

Properties / Fields

context (protected)

The InteractionContext this trigger belongs to. Set during Initialize().

protected InteractionContext context;

Common Pitfalls

Forgetting [Serializable] Triggers are serialized via Odin in the Inspector. Without [Serializable], the trigger will not persist.

Matching always returns false If using the generic path, the incoming trigger must be the exact same type or a subclass of TInteractionTrigger. A ClickTrigger will never match a ProximityTrigger.

Examples

Simple Click Trigger

using System;
using Paragon.Townskeep.InteractionSystem;

[Serializable]
public class ClickTrigger : InteractionTrigger<ClickTrigger>
{
    protected override bool IsMatch(ClickTrigger trigger)
    {
        // All click triggers match each other
        return true;
    }
}

Keyed Trigger (matching by ID)

using System;
using UnityEngine;
using Paragon.Townskeep.InteractionSystem;

[Serializable]
public class ZoneTrigger : InteractionTrigger<ZoneTrigger>
{
    [SerializeField]
    private string zoneId;

    public ZoneTrigger() { }

    public ZoneTrigger(string zoneId)
    {
        this.zoneId = zoneId;
    }

    protected override bool IsMatch(ZoneTrigger trigger)
    {
        return zoneId == trigger.zoneId;
    }
}

Using a Trigger at Runtime

var trigger = new ClickTrigger();
if (interactor.TryInteractWith(interactable, trigger, out var interaction))
{
    Debug.Log($"Started: {interaction.GetType().Name}");
}

See Also

• Interaction — the action executed when a trigger matches

• Interactor — entity that passes triggers to TryInteractWith

• InteractionTable — contains contexts with triggers