How-To: Bind Your Team System (Optional)

Goal: connect the Self / Ally / Enemy relationship rules to your project's team logic. The plugin has no team dependency of its own - it asks one overridable query, IsActorFriendly, at most twice per event. While no hook is provided every actor counts as an ally, so ShowAllyEffects governs every third-party event and ShowEnemyEffects never fires.

Prerequisites
A UCrimsonCombatTextPlayerSettings component on your PlayerController (How-To: Filter Which Pops a Player Sees) and some team system that can answer 'are these two actors friendly?'.

Provide the team hook

IsActorFriendly(LocalPawn, OtherActor) is a BlueprintNativeEvent on the component: return true when OtherActor is friendly to LocalPawn. OtherActor is whoever is being judged against the local pawn - currently the instigator of the event. Blueprint projects override the event on a component subclass; C++ projects can instead bind the IsActorFriendlyDelegate, which the native implementation falls back to.

Content Browser > right-click > Blueprint Class > search CrimsonCombatTextPlayerSettings and pick it as the parent. In the new Blueprint, open My Blueprint -> Functions, hover Override and choose Is Actor Friendly.

In the override graph: Is Actor Friendly -> (your team system's query, fed by the `Local Pawn` and `Other Actor` input pins) -> Return Node (Return Value = true when the two are friendly). Return true for a null Other Actor to keep the default everyone-is-friendly behavior.

Then add the subclass to your PlayerController in place of the base component: Components -> + Add -> (your Blueprint's name).

Precedence
A Blueprint override of IsActorFriendly takes precedence over the IsActorFriendlyDelegate - the delegate is only consulted by the native implementation, so it runs when nothing overrides the event (or when the Blueprint override calls the parent function).
Null instigators
On a client where the instigating actor is not net-relevant, the event's instigator resolves to null and the event is treated as third-party - your hook receives OtherActor = nullptr, so handle that case (returning true keeps the default everyone-is-friendly behavior).
Verify
With the Show Enemy Effects row off, damage dealt by an enemy-team actor to a third party no longer pops for this player, while an ally's damage still does. The dev tools Filters tab reports which team hook is active (Blueprint override / C++ delegate / none), and its decision trace prints the relationship each event resolved to - the fastest way to confirm your hook is being asked.
What the hook is asked about
Both the instigator and the target, separately, and always as pawns - event actors are resolved to their avatar before the hook sees them, so you never get handed a PlayerState here. A null side is passed through unchanged, and the native implementation answers friendly for it, which is what keeps events with an unresolvable source visible instead of silently dropped. If your team agents implement the engine's IGenericTeamAgentInterface (or your own team interface), read the two actors' teams through it and return true for a null OtherActor to keep that behavior.

See also

  • How-To: Filter Which Pops a Player Sees - the toggles this hook feeds.
  • How-To: Test Pops with the Dev Tools - broadcast enemy-instigated test events to exercise the hook.
  • API Reference - IsActorFriendly and the FCrimsonIsActorFriendlyDelegate signature.