Impact Numbers.

01What this plugin does#

When something takes damage (or gets healed) you usually want a number to pop up at that spot and float away. Impact Numbers does exactly that — and lets you style it completely: colour, font, outline, motion, formatting, sound, and more.

You do not write rendering or pooling code. You call one function with a world position and a value; the plugin spawns, animates, recycles and cleans up the visuals for you, efficiently.

It does not calculate damage. You decide how much damage a hit does (and whether it was a crit, block, miss); you pass the final number and an optional "modifier" label, and the plugin shows it in the matching style.

Promise: drop in → pick one config asset → call one function → done.

02Requirements & installation#

Requirements

• Unreal Engine 5.7 (Win64).
• A project that can compile C++ (install Visual Studio 2022 with the Game development with C++ workload). Blueprint-only projects work too — see the tip below.

Install

1. Copy the ImpactNumbers folder into your project's Plugins/ folder:

   <YourProject>/Plugins/ImpactNumbers/ImpactNumbers.uplugin

2. If your project has no Source/ folder (Blueprint-only), create any C++ class once: Tools → New C++ Class → None. This lets the editor compile the plugin.
3. Right-click your .uproject → Generate Visual Studio project files.
4. Open the project. If prompted to rebuild missing modules, click Yes.
5. Confirm it's on: Edit → Plugins, search Impact Numbers.

GameplayTags is a built-in engine feature — there is nothing extra to enable.

03Quick start (5 minutes)#

1. Create the config asset. Content Browser → Add → Miscellaneous → Data Asset → choose Impact Number Config → name it DA_ImpactNumbers.

   (Optional shortcut: open the console with the ` key and run ImpactNumbers.GenerateDemoConfigs to get ten ready-made configs — see Section 12.)

2. Select it. Edit → Project Settings → Plugins → Impact Numbers → Active Config → pick DA_ImpactNumbers. (This is the only required setup step.)
3. Show a number.

   Blueprint

   In the Level Blueprint, off BeginPlay add a Set Timer by Event (0.3s, looping) and from it call Show Damage Number:

   • World Location = Player Pawn location + (0,0,100)
   • Amount = a random number

   C++

   #include "ImpactNumbersLibrary.h"
   UImpactNumbersLibrary::ShowDamageNumber(this, GetActorLocation() + FVector(0,0,100), 123.0f);

4. Press Play. Numbers float up above the player.

04Key concepts#

Three ideas explain the whole plugin:

1. One function

ShowDamageNumber(WorldContext, WorldLocation, Amount, ...). Everything after Amount is optional.

2. One config, layered overrides

A single Impact Number Config asset holds a Default Style plus a list of Modifier Overrides (one per gameplay tag, e.g. crit/heal/miss). Every style field has a small checkbox next to it ("override this field?"). Unchecked fields fall back to the layer below.

The final style for a hit is merged in this order, last one wins per field:

Default Style  →  Explicit Preset (optional)  →  Modifier Override (by tag)

The per-tag modifier override is applied last, so your project's config always has the final say over a preset passed from code.

3. Pooled & automatic

One screen overlay (or pooled world widgets) is reused for every number, capped by Max Concurrent Numbers. You never manage widgets.

05The config Data Asset#

UImpactNumberConfig is the heart of the plugin. Open your DA_ImpactNumbers:

The override checkboxes

Each style field (e.g. Base Color) has a checkbox.

• Unchecked → the field is ignored at this layer and inherited from below.
• Checked → this layer sets the field.

So a Crit modifier might check only Base Color (red) and Base Font Size (48) — everything else stays as the Default Style. This is the same pattern Unreal uses for Post Process Volumes.

06Calling the function#

The one function

UImpactNumbersLibrary::ShowDamageNumber(
    WorldContextObject,  // any object in the world (this)
    WorldLocation,       // FVector — where the number appears
    Amount,              // float  — the value to show
    ModifierTag,         // FGameplayTag — optional style selector
    Target);             // AActor*      — optional owner (stacking/rate-limit)

In C++ there are convenience overloads, so the minimal call is:

UImpactNumbersLibrary::ShowDamageNumber(this, Location, Amount);
UImpactNumbersLibrary::ShowDamageNumber(this, Location, Amount, MyTag);
UImpactNumbersLibrary::ShowDamageNumber(this, Location, Amount, MyTag, TargetActor);

In Blueprint, add the Show Damage Number node. World Context is supplied automatically. Modifier Tag and Target live under the node's Advanced (the small arrow at the bottom) and are optional.

With an explicit preset

If you want to pass a whole style from code (rare), use:

UImpactNumbersLibrary::ShowDamageNumberWithPreset(this, Location, Amount, Preset, Tag, Target);

Preset is an FImpactNumberStyle; its checked fields apply between the default and the modifier layer.

Where do I call it?

Wherever your game applies damage. Typical spots: AnyDamage/PointDamage events, your ApplyDamage function, an ability's "on hit", etc. Example:

void AEnemy::HandleHit(float FinalDamage, FGameplayTag HitTag, AActor* Causer)
{
    Health = FMath::Max(0.f, Health - FinalDamage);            // your logic
    UImpactNumbersLibrary::ShowDamageNumber(                    // the visual
        this, GetActorLocation() + FVector(0,0,90), FinalDamage, HitTag, this);
}

07Modifiers & gameplay tags#

A modifier is a named variation of the look, selected by a gameplay tag.

1. Create the tags. Edit → Project Settings → Project → GameplayTags → Manage Gameplay Tags → +. Suggested:
   • ImpactNumbers.Crit
   • ImpactNumbers.Heal
   • ImpactNumbers.Miss
   • ImpactNumbers.Block

   (You can use any names. The ImpactNumbers.GenerateDemoConfigs console command creates these four for you.)

2. Add overrides in the config. In DA_ImpactNumbers → Modifier Overrides → + → set the key to a tag → check the fields you want to change.
3. Pass the tag when calling the function. No tag (empty) = just the Default Style.

Showing text instead of a number (MISS, BLOCK): on that modifier, check Behavior → Format → Override Text and type the word. The number is then ignored for that modifier.

Number + label (e.g. 250 Critical!): use Prefix or Suffix instead of Override Text.

08Per-enemy configs#

Want different enemies to show different number styles without changing your calling code? Use the component:

1. On the enemy actor/Blueprint: Add Component → Impact Numbers Config.
2. Set its Config to a dedicated UImpactNumberConfig for that enemy.
3. Pass that enemy as the Target in ShowDamageNumber (you usually already do).

The plugin reads the component from the Target and uses its config to resolve the style. Enemies without the component use the global config from Project Settings. The shared overlay, pool and pool cap stay global — only the look/behaviour changes per enemy.

09Full parameter reference#

All fields are optional via their override checkbox. Fields are grouped under the Default Style (and each modifier) in the details panel.

Render space

World Space only

Screen Space only

Value / format (Behavior → Format)

Icon (Style → Icon)

Follow target (Behavior → Follow)

Typography

Colour

Animation

Motion

Spawn placement (Motion → Spawn)

Stacking (Behavior → Stacking)

Limits / performance (Behavior → Limits)

Audio (Behavior → Audio)

10Working with curves#

Several of the best-looking features are driven by Curve assets. Two types:

• Curve Float — a single value over an input (used for Scale, Opacity, Size By Amount, Distance Scale).
• Curve Linear Color — an RGBA colour over an input (used for Color Over Life, Color By Amount).

Create one: Content Browser → Add → Miscellaneous → Curve → choose CurveFloat or CurveLinearColor. Double-click to edit; right-click in the graph to add keys.

What the X axis means:

• Scale Curve / Opacity Curve / Color Over Life Curve → X is normalised lifetime from 0 (spawn) to 1 (death).
• Size By Amount / Color By Amount → X is the damage amount you pass.
• Distance Scale Curve → X is the camera distance in world units.

Example — a satisfying "pop": a Scale Curve with keys (0, 0.3) → (0.12, 1.25) → (0.25, 1.0) → (1.0, 1.0) grows fast, slightly overshoots, then settles.

The advanced demo command (ImpactNumbers.GenerateAdvancedDemoConfigs) creates reusable example curves named C_IN_PopScale, C_IN_FadeInOut, C_IN_LifeGradient, C_IN_AmountColor, C_IN_AmountSize, C_IN_DistanceScale.

11Use cases & recipes#

Each recipe is a set of fields to check on a Default Style or a modifier.

Basic damage

Default Style: Base Color white, Base Font Size 28, Motion Type Float Up, Initial Speed 120, Lifetime 1.0.

Critical hit

Modifier ImpactNumbers.Crit: Base Color gold, Base Font Size 48–56, Motion Type Fountain, Suffix !, Outline on. (Your code multiplies the damage and passes the Crit tag.)

Healing

Modifier ImpactNumbers.Heal: Base Color green, Sign Mode Always (+), or Prefix +.

Miss / Block

Modifiers with Override Text MISS / BLOCK, grey/blue colour. (Your code sets damage to 0 / reduced and passes the tag.)

Damage over time (poison/burn)

Motion Type Fall, small Base Font Size, short Lifetime, green colour, optional Start Delay to stagger ticks.

MMO-style big numbers

Abbreviation Short (1.2K), Size By Amount Curve so big hits are physically bigger, Color By Amount Curve white→red.

Bullet-hell / many hits

Enable Stacking with a small window and an Anti Overlap Offset; set a sensible Rate Limit Per Target and a lower Max Concurrent Numbers.

3D world labels (e.g. boss)

Space World, Face Camera on, Distance Scale Curve, Occlusion Test on so numbers hide behind walls.

Arcade burst

Motion Type Scatter, Direction Spread ~75°, Gravity, Spread Radius, bright colour + outline.

11aAdvanced features#

Icons / sprites next to the number

Any number can show a texture icon to the left or right of the text.

1. In your config (Default Style or a modifier), expand Style → Icon.
2. Set Icon to a texture.
3. Set Icon Position (Left / Right) and Icon Size in pixels.

The built-in default widget contains left and right slots that the plugin shows and hides automatically. Blueprint widget subclasses bind LeftIconImage / RightIconImage via BindWidgetOptional for custom layouts.

Count-Up number animation

Make the displayed value animate from 0 to the final amount when the number first appears. In Behavior → Format: enable Count Up and set Count Up Duration (e.g. 0.5 seconds).

The value counts linearly from 0 to Amount over the duration, then stays fixed. Works with stacking — a new merge resets the count-up from 0 to the combined total.

Follow moving target

Keep the number floating above a moving actor (e.g. a running enemy). In Behavior → Follow, enable Follow Target, then always pass the target actor in the Target parameter of ShowDamageNumber.

The motion arc (FloatUp, Arc, etc.) plays in the target's local frame so the number follows the target while still floating away naturally.

Multiplayer helper (replicated component)

For a number visible to all connected clients (not just the local player):

1. Add the Impact Numbers Replication Component to your replicated actor (the owning actor must have bReplicates = true).
2. Call ShowNumberReplicated(WorldLocation, Amount, ModifierTag) from your server-side damage code instead of ShowDamageNumber.

The component sends a Server RPC → NetMulticast automatically. Each client's local subsystem then spawns the visual using its own viewport and pooled widgets, so there is no network traffic beyond the initial RPC.

// C++ — on the server, inside ApplyDamage:
if (UImpactNumbersReplicationComponent* Comp =
        Enemy->FindComponentByClass<UImpactNumbersReplicationComponent>())
{
    Comp->ShowNumberReplicated(HitLocation, FinalDamage, CritTag);
}

Blueprint events (OnSpawned / OnExpired)

Bind to the subsystem delegates in Blueprint or C++ to react when any number spawns or expires.

Blueprint: call Get Impact Numbers Subsystem (library node, WorldContextObject auto-filled), then drag out and select Assign On Number Spawned or Assign On Number Expired.

// C++
if (UImpactNumbersSubsystem* Sub = UImpactNumbersSubsystem::Get(this))
{
    Sub->OnNumberSpawned.AddDynamic(this, &AMyActor::HandleNumberSpawned);
    Sub->OnNumberExpired.AddDynamic(this, &AMyActor::HandleNumberExpired);
}

OnNumberSpawned delivers (FVector WorldLocation, float Amount, FGameplayTag ModifierTag). OnNumberExpired delivers (FVector LastLocation, float Amount).

Per-call overrides (colour / text / icon)

Override the colour, text, or icon for a single call without touching the config or adding a named modifier tag.

// C++ — tint one number red without changing the config:
FImpactNumberCallOverrides Overrides;
Overrides.bOverride_Color = true;
Overrides.Color = FLinearColor::Red;
UImpactNumbersLibrary::ShowDamageNumberEx(this, Location, Damage, Overrides, Tag, Target);

Blueprint: use the Show Damage Number Ex node. The Overrides pin expands to bOverride_Color / Color, bOverride_Text / Text, and bOverride_Icon / Icon. Only enabled overrides are applied; the rest falls back to the config.

Resolution order: Config default → Overrides → ModifierTag (tag still wins last).

Combinable modifier tags (TagContainer)

Apply multiple modifier overrides at once by passing a FGameplayTagContainer instead of a single tag. Each tag's override is applied in iteration order; later tags win per field.

FGameplayTagContainer Tags;
Tags.AddTag(FGameplayTag::RequestGameplayTag("ImpactNumbers.Crit"));
Tags.AddTag(FGameplayTag::RequestGameplayTag("ImpactNumbers.Elemental"));
UImpactNumbersLibrary::ShowDamageNumberWithTags(this, Location, Damage, Tags, Target);

Blueprint: use the Show Damage Number With Tags node. The Modifier Tags pin accepts a Make GameplayTagContainer node.

11bGAS Bridge (Gameplay Ability System)#

The optional ImpactNumbersGAS module wires your existing GAS setup to Impact Numbers with zero ability or attribute-set code. Attach one component, configure a few fields, and numbers appear automatically whenever GAS modifies your attributes or applies a GameplayEffect.

This module is entirely optional. The core ImpactNumbers module has no GAS dependency. Add ImpactNumbersGAS to your project's module list only when you use GAS.

Setup

1. Enable the module. In your game project's Build.cs, add "ImpactNumbersGAS" to PublicDependencyModuleNames. The engine's GameplayAbilities plugin must also be enabled.
2. Add the component. Select the actor that owns the UAbilitySystemComponent (or implements IAbilitySystemInterface), click Add Component, and choose Impact Numbers GAS.
3. Pick the integration mode under Impact Numbers|GAS → Integration Mode.
4. Configure attributes / tag mapping (see below).
5. Play. Numbers appear automatically from that point.

If the ASC lives on a different actor (e.g. PlayerState), assign it to Explicit Ability System Component. For actors that acquire their ASC after BeginPlay (e.g. possessed AI), call BindToAbilitySystem(ASC) from Blueprint or C++ once the ASC is ready.

Integration modes

Attribute Change mode (recommended default)

Binds GetGameplayAttributeValueChangeDelegate per watched attribute. Fires whenever an attribute changes — predicted client-side changes included. Configure Watched Attributes:

Effect Applied mode

Binds OnGameplayEffectAppliedDelegateToSelf. Richer than attribute change: reads the hit location from the GE effect context (if set by the ability) and maps GE tags to Impact Numbers modifier tags via Tag Mapping (a TMap<FGameplayTag, FGameplayTag>):

• Key: a GAS tag on the applied GE (asset or granted tag), e.g. GE.Damage.Crit.
• Value: the Impact Numbers modifier tag to use, e.g. ImpactNumbers.Crit.

First match wins. If no entry matches, Default Damage Modifier Tag is used.

For the hit location to come from the GE context, the ability must call EffectContextHandle.AddHitResult(HitResult) when building the FGameplayEffectSpecHandle.

Common properties

Runtime API

// Called automatically from BeginPlay. Re-call after possession with a new ASC.
GASComp->BindToAbilitySystem(NewPawn->GetAbilitySystemComponent());

// Clean up before unpossession / actor destruction.
GASComp->UnbindFromAbilitySystem();

// Query.
UAbilitySystemComponent* BoundASC = GASComp->GetBoundAbilitySystemComponent();

All three functions are also BlueprintCallable.

Multiplayer considerations

12Ready-made demo configs#

Two editor console commands generate complete example configs under /ImpactNumbers/Data (enable Show Plugin Content in the Content Browser settings to see them). Open the console with the ` key.

ImpactNumbers.GenerateDemoConfigs

Creates 10 straightforward presets (classic, gold crit, green heal, abbreviation, thousands separator, outlined bold, world floaty, scatter arcade, MISS/BLOCK status text, minimal fast) and registers the demo tags.

ImpactNumbers.GenerateAdvancedDemoConfigs

Creates 10 advanced, curve-driven presets (pop scale, colour over life, colour by amount, size by amount, spin arc, stacking, DoT fall, world distance + occlusion, performance guardrails, and a combined showpiece) plus their curve assets.

Pick any generated DA_IN_Demo_* as your Active Config to try it.

13Custom widgets#

The default widgets build themselves, so you usually do nothing. To use your own design:

1. Create a Blueprint subclass of ImpactNumberTextWidget. Add a Text Block named exactly TextBlock. Style it freely (you can add backgrounds, icons, etc. around it).
2. (Optional) Blueprint subclass of ImpactNumbersOverlayWidget with a Canvas Panel named RootCanvas.
3. In your config under Widgets, assign Entry Widget Class / Overlay Widget Class.

The exact widget names matter — that's how the engine binds your designer elements to the plugin. Without them, the built-in fallback is used.

14Performance guide#

Impact Numbers is built to be cheap, but you control the budget:

• Max Concurrent Numbers (config) — the hard cap. Lower it for mobile / busy scenes. The oldest number is recycled when exceeded.
• Rate Limit Per Target — prevents a single fast-hitting source from flooding.
• Culling Distance / Skip When Off Screen — don't spawn what the player can't see.
• Stacking — merges bursts into one number, drastically cutting count.
• Prefer Screen Space for huge counts (one overlay) over many world widgets.

Everything updates from a single subsystem tick — there is no per-number Tick and no actor/widget is spawned per hit.

15Editor validation#

When you save a config, the plugin checks it and shows messages in the Message Log / Data Validation:

• Error: an empty/invalid gameplay tag key in Modifier Overrides (it would never match).
• Warnings: invisibly short Lifetime, huge Base Font Size, World Space with no Distance Scale Curve / size clamps, Abbreviation cancelling Fractional Digits, Stacking enabled with a zero window.

You can also run Tools → Validate Assets / Validate Data on the folder.

16Troubleshooting & FAQ#

FAQ

• Does it apply damage? No. You compute damage; you pass the final number.
• Networking — only one client sees the number? Use UImpactNumbersReplicationComponent::ShowNumberReplicated on a replicated actor. See Advanced features.
• Can I mix screen and world space? Yes — per preset and per modifier.
• Blueprint only? Yes for usage; the project must still be able to compile the plugin's C++.
• Count-up doesn't animate? Check that Count Up Duration is shorter than Lifetime and the override checkbox is enabled.
• Follow target lags behind? The follow tracks the actor's root position. For actors with a complex bone hierarchy, compute a socket location before calling ShowDamageNumber.

17API reference#

Function library — UImpactNumbersLibrary

• ShowDamageNumber(WorldContextObject, WorldLocation, Amount, ModifierTag, Target) — the one function.
• ShowDamageNumberWithPreset(WorldContextObject, WorldLocation, Amount, Preset, ModifierTag, Target) — explicit style preset.
• ShowDamageNumberEx(WorldContextObject, WorldLocation, Amount, Overrides, ModifierTag, Target) — per-call colour/text/icon overrides without a named modifier.
• ShowDamageNumberWithTags(WorldContextObject, WorldLocation, Amount, ModifierTags, Target) — stacked FGameplayTagContainer overrides.
• GetImpactNumbersSubsystem(WorldContextObject) → UImpactNumbersSubsystem* — access delegates.
• C++ overloads omit trailing Target / ModifierTag.

Config — UImpactNumberConfig (Data Asset)

• DefaultStyle, ModifierOverrides, MaxConcurrentNumbers, OverlayWidgetClass, EntryWidgetClass.
• ResolveStyle(ModifierTag, ExplicitPreset) — single-tag resolution.
• ResolveStyleForTags(ModifierTags, ExplicitPreset) — multi-tag stacked resolution.

Settings — UImpactNumbersSettings (Project Settings → Plugins)

• ActiveConfig.

Components

• UImpactNumbersConfigComponent — per-actor style config override.
• UImpactNumbersReplicationComponent — multiplayer helper; call ShowNumberReplicated for all-client visibility.
• UImpactNumbersGASComponent (ImpactNumbersGAS module) — GAS bridge; wires attribute-change or GE-applied delegates to ShowDamageNumber automatically. Properties: IntegrationMode, WatchedAttributes, TagMapping, DefaultDamageModifierTag, DefaultHealModifierTag, GlobalMinDisplayAmount, bOnlyShowOnLocallyControlledOwner, ExplicitAbilitySystemComponent. Methods: BindToAbilitySystem, UnbindFromAbilitySystem, GetBoundAbilitySystemComponent.

GAS Types (ImpactNumbersGAS module)

• EImpactNumberGASMode: AttributeChange, EffectApplied
• FImpactNumberGASAttributeConfig — per-attribute config for AttributeChange mode (Attribute, MinDisplayAmount, bTreatDecreaseAsDamage, bShowHeal, ActorLocationOffset).

Subsystem — UImpactNumbersSubsystem (UWorldSubsystem)

• Owns pooling, both render spaces, the update loop and projection. You normally don't call it directly; the library routes through it.
• OnNumberSpawned (FOnImpactNumberSpawned) — fired when any number spawns.
• OnNumberExpired (FOnImpactNumberExpired) — fired when any number's lifetime elapses.

Structs

• FImpactNumberStyle (umbrella) → contains FImpactNumberMotion and FImpactNumberBehavior. Every field has a bOverride_ toggle.
• FImpactNumberCallOverrides — lightweight per-call overrides (colour, text, icon).

Enums

• EImpactNumberSpace: ScreenSpace, WorldSpace
• EImpactNumberMotionType: FloatUp, Arc, Scatter, Fountain, Hover, Fall
• EImpactNumberRounding: None, Nearest, Floor, Ceil
• EImpactNumberAbbreviation: None, Short
• EImpactNumberSignMode: Auto, Always, Never
• EImpactNumberIconPosition: Left, Right

Editor console commands

• ImpactNumbers.GenerateDemoConfigs
• ImpactNumbers.GenerateAdvancedDemoConfigs

18Glossary (for beginners)#

• Data Asset — a content file that just holds settings (no logic). Here, your config.
• Project Settings — the project-wide options window (Edit → Project Settings).
• Gameplay Tag — a hierarchical label like ImpactNumbers.Crit used to pick a modifier.
• World Location — a 3D position in the level (FVector).
• World Context — any object that knows which game world it's in; in Blueprint it's filled in automatically, in C++ pass this.
• Blueprint node — a visual function block; Show Damage Number is the one you use.
• Subsystem — an engine-managed singleton that lives with the game world.
• Curve asset — a content file describing a value (or colour) over an input, edited in a graph.
• Pooling — reusing a fixed set of objects instead of creating/destroying them constantly (faster).
• GAS — Unreal's Gameplay Ability System, a framework for abilities, attributes (e.g. Health), and gameplay effects.
• Attribute — a GAS value like Health or Mana, held in an Attribute Set and changed via Gameplay Effects.
• GameplayEffect (GE) — a GAS data object that modifies attributes (e.g. "deal 30 damage").
• Delegate — an event you can bind a function to; fires when something happens (e.g. a number spawns).

19Version & maintenance#

• Plugin version: 1.0 — Engine: Unreal Engine 5.7.

For support: seoulmediastudio.com/kontakt