Character Vitals.

01What this plugin does#

Character Vitals gives any character (the player, NPCs, animals, bosses — anything that is an Actor) a set of vital stats. A stat is just a number that can go up or down over time, like:

• Health that drops when you take damage and regenerates slowly.
• Stamina that drains while sprinting and refills while resting.
• Hunger and Thirst that slowly tick down until you eat or drink.
• Temperature that changes near fire or in cold areas.
• Anything else — Sanity, Oxygen, Radiation, Mana… you define it.

The plugin handles all the hard parts automatically: a self-updating HUD, decay/regeneration over time, buffs and debuffs with timers, "conditions" like Starving or Freezing, a built-in day/night cycle, save and load support, and full multiplayer (server-authoritative) replication.

You configure everything in a single asset and connect a few Blueprint nodes. You never have to write C++.

02Key concepts for beginners#

If you already know Unreal, skip to installation. Otherwise, here are the only five terms you need:

Three pieces make Character Vitals work:

Vital Signs Component  ──reads──▶  Vital Signs Data Asset
(attached to your                 (your stat settings)
 character)
       │ shows
       ▼
  HUD Widget   ← the bars the player sees

You will: (1) add the Component to your character, (2) assign a Data Asset to it, (3) assign a HUD widget. That's the whole setup.

03Installing the plugin#

Option A — Install into an existing project

1. Close the Unreal Editor if it's open.
2. In your project folder, find (or create) a folder named Plugins — e.g. MyGame/Plugins/.
3. Copy the entire CharacterVitals folder into Plugins. You should end up with MyGame/Plugins/CharacterVitals/CharacterVitals.uplugin.
4. Open your project. Unreal may ask to rebuild the plugin — click Yes.
5. Go to Edit → Plugins, search for CharacterVitals, and make sure the checkbox is enabled. Restart if prompted.

Important: This plugin contains C++ source. Your project must be a C++ project (or have Visual Studio installed) so the editor can compile it the first time. Blueprint-only project? The easiest fix: Tools → New C++ Class → None → Create Class. This converts your project to C++ once; you still never write any code.

Option B — Enabled by default

This plugin ships with EnabledByDefault = true, so once it's in the Plugins folder and compiled, it is active. Find its content under Content Browser → Plugins → CharacterVitals Content (enable Show Plugin Content in the Content Browser's Settings if you don't see it).

Requirements

• Unreal Engine 5.7
• Windows (Win64) — this build targets Win64.
• The Enhanced Input plugin (enabled automatically as a dependency).

04The 5-minute quick start#

This sets up a working health/stamina/hunger system on a character from scratch.

Step 1 — Open your character Blueprint

In the Content Browser, double-click your character Blueprint (e.g. BP_ThirdPersonCharacter). No character yet? Use the plugin's ready-made BP_VitalCharacter (see the demo).

Step 2 — Add the Vital Signs Component

1. In the character Blueprint, look at the Components panel (top-left).
2. Click the green + Add button.
3. Type Vital Signs and pick Vital Signs Component.

Step 3 — Create a Data Asset

1. Content Browser → + Add → Miscellaneous → Data Asset.
2. Choose Vital Signs Data Asset. Name it DA_MyVitals.
3. Double-click to open. Click + next to Stats to add a stat. A minimal Health stat:
   • Stat Name: Health · Display Name: Health
   • Default Value: 100 · Min: 0 · Max: 100
   • Direction: Regen Only · Regen Rate: 1 · Critical Threshold: 25
4. Add a second stat: Stat Name Hunger, Direction Decay Only, Decay Rate 1.
5. Save (Ctrl+S).

Tip: You don't have to build from zero. The plugin includes DA_CharacterVitals (under Plugins → CharacterVitals Content → Core/Data/Character) with Health, Stamina, Hunger, Thirst and Temperature fully set up. Assign it directly and skip building your own.

Step 4 — Assign the Data Asset

Select the Vital Signs Component → in Details find Vital Signs → Vital Data Asset → set it to DA_MyVitals (or the included DA_CharacterVitals).

Step 5 — Assign a HUD widget

Still on the component, find Vital Signs → Widget Class and choose WBP_VitalSigns_Survival (full survival HUD) or WBP_VitalSigns_Minimal (compact). Compile and Save.

Step 6 — Press Play

You'll see the vital bars on screen, Hunger slowly ticking down, and bars turning their critical color when low. That's a working system.

05Trying the included demo#

1. Enable plugin content: Content Browser → Settings → Show Plugin Content.
2. Navigate to CharacterVitals Content → Maps.
3. Open L_VitalsDemo and press Play.

The demo includes a playable character (BP_VitalCharacter) with the full HUD, a BP_VitalDayTimeManager driving a live day/night cycle, trigger volumes for temperature/time/stat-restoration, and a campfire that warms you up. Open these Blueprints to see exactly how the plugin's nodes are used — they're the best "by example" reference you have.

06The Data Asset — configuring your stats#

The Vital Signs Data Asset is the heart of the system. One asset describes one type of character (e.g. one for the Player, one for an Enemy).

Stats (the main array)

Each entry in Stats is one vital. The most important fields:

How "rates" work: Stats update on a timer, not every frame. By default the timer is once per second (Update Interval = 1.0). A Decay Rate of 1 means the stat loses 1 point each second.

Performance

Widget | HUD

Audio

Optionally play a sound when any stat goes critical (Play Sound On Critical + Critical Sound) or depleted (Play Sound On Depleted + Depleted Sound).

Passive Conditions & Condition Display

Define automatic states like Starving or Exhausted (see Passive conditions). Condition Display controls how condition icons appear: which widget to use, fade durations, and an optional hold-to-inspect key (an Enhanced Input Action) that reveals condition names while held.

07The HUD widget — showing stats on screen#

Option A — Use a ready-made widget (recommended for beginners)

Just assign WBP_VitalSigns_Survival or WBP_VitalSigns_Minimal to the component's Widget Class. The plugin creates and displays it automatically. Nothing else to do.

Option B — Design your own HUD

The system auto-binds your UI to stats by widget name. You design freely and the plugin fills in the values — no nodes required.

1. Create a Widget Blueprint: right-click in Content Browser → User Interface → Widget Blueprint.
2. For the parent class, choose Vital Signs Widget (not the default UserWidget).
3. Design your layout. For each stat, add widgets and name them by this convention:

   Widget type	Name it	Example for "Hunger"
   Progress Bar	PB_{StatName}	PB_Hunger
   Text Block (optional)	TXT_{StatName}	TXT_Hunger
   Image / icon (optional)	IMG_{StatName}	IMG_Hunger

   The {StatName} must exactly match the Stat Name in your Data Asset.
4. Make each named widget a variable (check Is Variable, top-right of Details) so the plugin can find it.
5. Assign this widget to the component's Widget Class. Done — bars, text and icons now update automatically.

Customizing behavior (optional)

Inside your widget Blueprint you can override these events to add polish (animations, screen shakes, etc.). The bars/colors are already updated before these fire:

• On Widget Initialized
• On Stat Value Changed
• On Stat Entered Critical / On Stat Recovered
• On Stat Became Depleted
• On Condition Activated / On Condition Deactivated

There's also a Bar Animation Speed setting on the widget (higher = snappier bars, 0 = instant).

08Changing stats from Blueprints#

There are two equally valid ways to call the functions.

The easy way — the Vitals Function Library

These global nodes work from anywhere (the character, an item, an ability, the level Blueprint). You just pass the target Actor — no need to grab the component first.

Example: a health potion heals 25 HP.

Event (e.g. On Used)
   └─▶ Modify Stat
         Target    = [the player Actor]
         Stat Name = Health
         Amount    = 25

Example: sprinting drains stamina, resting refills it.

While sprinting:  Modify Stat (Stamina, -5)
While resting:    Modify Stat (Stamina, +10)

Common library nodes (full list in the function reference):

• Modify Stat (Target, StatName, Amount) — add/subtract. Positive heals, negative damages.
• Set Stat (Target, StatName, Value) — set to an exact number.
• Fill Stat / Drain Stat — jump to max / min.
• Get Stat Value / Get Stat Percent — read current value (percent is 0–1, great for bars).
• Is Stat Critical / Is Stat Depleted — boolean checks.

The direct way — via the component

If you already have a reference to the Vital Signs Component, call its functions directly: Modify Vital, Set Vital, Get Vital Value, Get Vital Percent, Fill Vital, etc. Same behavior, just called on the component.

Beginner tip: Use the Function Library nodes. They're simpler because you don't have to find the component first.

09Reacting to events#

The Vital Signs Component broadcasts events you can react to. In your character Blueprint, drag from the Vital Signs Component and search for these "Assign / Bind Event" delegates, or add them via the component's Details panel:

Example: trigger death when Health is depleted.

On Vital Depleted (StatName)
   └─▶ Branch: StatName == "Health"
          True ──▶ [play death animation / ragdoll / respawn]

10Combat — damage, healing, death#

Dealing damage and healing

• Deal Damage (Instigator, Target, Damage, StatName="Health") — subtracts health, fires combat events, and returns true if the target died.
• Heal (Target, Amount, StatName="Health") — heals, no combat events.
• Kill (Killer, Target, StatName="Health") — instantly depletes the stat.
• Can Afford (Target, StatName, Cost) — check if there's enough (e.g. mana).
• Spend (Target, StatName, Cost) — deduct a cost; returns false if too low (perfect for ability costs).

Reacting to combat with the Combat Interface

For clean, reusable combat reactions, implement the Vital Combat Interface on your character:

1. Open your character Blueprint → Class Settings (toolbar).
2. Under Interfaces → Implemented Interfaces, click Add → choose Vital Combat Interface.
3. Compile. Now in My Blueprint you can add these events:

Deal Damage and Kill automatically call these on the relevant Actors, so your hit reactions and death logic stay neatly in one place.

Pairs perfectly with Impact Numbers. Call ShowDamageNumber from On Vital Damage Received to get floating combat numbers on every hit.

11Buffs & debuffs (modifiers)#

A modifier temporarily changes how fast a stat decays or regenerates — poison (faster decay), a heal-over-time (faster regen), a "well-fed" buff.

Applying a modifier

Use Apply Modifier (Target, Modifier). Build the Modifier struct (right-click the input pin → Split Struct Pin):

Example: poison that drains Health faster for 10 seconds.

Apply Modifier
  Modifier Name        = Poison
  Stat Name            = Health
  Decay Rate Modifier  = 5
  Duration             = 10

Managing modifiers

• Remove Modifier (Target, ModifierName) — remove one by name.
• Remove All Modifiers (Target) — clear everything.
• Has Modifier (Target, ModifierName) — check if active.
• Get Modifiers (Target, StatName) / Get Modifier Count — inspect them.

When a modifier ends, the On Modifier Expired event fires.

12Passive conditions (Starving, Exhausted, …)#

A passive condition is an automatic state that turns on when stats meet a rule and off when they don't — like Starving (Hunger very low) or Hypothermic (Temperature very low). Defined entirely in the Data Asset; you don't script them.

Setting one up

1. Open your Data Asset → Passive Conditions → click +.
2. Fill in: Condition Name Starving, Display Name, Icon + Display Color, Enabled true.
3. Requirements: add one or more — e.g. Stat Hunger, Below Value 15. Require All: true = ALL must be met (AND); false = ANY (OR).
4. Set the Condition Widget Class under Condition Display to WBP_Condition (included) so an icon shows up.
5. Save.

Now when Hunger drops below 15, the Starving icon appears automatically and On Condition Activated fires. When Hunger rises again, it disappears and On Condition Deactivated fires.

Querying conditions

• Is Condition Active (Target, ConditionName) — true/false.
• Get Active Conditions (Target) — array of all active condition names.

Manual conditions (gameplay-driven icons)

Show icons not tied to stat rules — e.g. a Warm icon while near a campfire:

• Show Condition (Target, Name, DisplayName, Icon, Color) — show it.
• Hide Condition (Target, Name) — hide it.
• Show Timed Condition (…, Duration) — show it and auto-hide after N seconds.

The plugin ships with ready-made condition icons: Bleeding, Burning, Dehydrated, Exhausted, Freezing, Healing, Infected, Poisoned, Starving, Stunned, Wet, Blessed.

Hold-to-inspect

If Hide Condition Names Default is on, only icons show. Assign an Inspect Conditions Action (an Enhanced Input Action — IA_InspectConditions is included) and the player can hold a key to reveal all condition names.

13Stat influences (stats affecting stats)#

An influence lets one stat automatically change another when it gets low. Classic survival example: "when Hunger is low, Health starts dropping."

Set this up on the source stat in the Data Asset, under its Influences array:

Example: starvation damages health. On the Hunger stat, add an influence: Target Health, Trigger Below 20, Influence Amount -2. Now whenever Hunger is under 20, Health loses 2 per tick. The On Vital Stat Influenced event fires each time.

14Day & night cycle#

A — Full visual day/night (easiest, looks great)

Use the included Vital Day Time Manager actor — a complete sun/moon/sky/fog system in one drag-and-drop actor.

1. Drag BP_VitalDayTimeManager into your level (place just one).
2. Select it and set Start Time Of Day (0–24; 12 = noon, 6 = sunrise) and Day Length Minutes (real minutes for a full 24h cycle; 20 = 20 min/day).
3. Press Play. The sun moves, sky and fog shift, night gets dark — automatically.

It also syncs time to the player's Vital Signs Component, so any per-stat day/night multipliers take effect with no extra wiring. Tune everything in its Details panel: sun/moon colors and intensity, optional moon mesh, fog density day vs. night, post-process exposure/tint. Events On Day Started, On Night Started, On Day Time Updated are available.

B — Time on the component only (no visuals)

If you just want stats to behave differently at night: on the Vital Signs Component, enable Enable Day Night Cycle, set Start Time Of Day and Day Length Minutes. On any stat, expand Day Night Config, enable it, and set Day/Night Decay Multipliers (e.g. Temperature decays 1.5× faster at night).

Driving your own lights

Prefer your own sky setup? Read these and feed them into your Directional Light:

• Get Sun Rotation → plug into Set World Rotation on your sun light.
• Get Sun Angle (0–360), Get Sun Height (−1 to 1), Is Daytime.
• Set Time Of Day (Hours) / Get Time Of Day to control/read time.

15Critical screen effect#

Show a full-screen warning (like a pulsing red vignette) when a stat gets dangerously low.

1. On the Vital Signs Component, enable Enable Critical Screen Effect.
2. Keep Use Built In Effect on for the ready-made pulsing vignette, or turn it off and assign your own Critical Effect Material (a Post Process material; it receives CriticalAlpha 0–1 pulsing and CriticalLevel 0–1 severity).
3. On the stat to monitor (e.g. Health), add one or more Critical Effect Levels: Below Value, Effect Intensity, Pulse Speed, Effect Color.

Add multiple levels for escalating danger:

The most severe active level always wins.

16Saving & loading#

Quick approach — built-in Save Game object

The plugin includes UVitalsSaveGame with simple static nodes:

// To save
Save Stats (Target = Player)        → returns an array of save data
Load Or Create (Slot = "Slot1")     → returns a Save Game object
[set the object's Character Data.Stats to the array above]
Save To Disk (the Save Game object)

// To load
Does Save Exist ("Slot1")?  → Branch
  True ─▶ Load Or Create ("Slot1")
         └─▶ Load Stats (Target = Player, SaveData = object's Character Data.Stats)

Other helpers: Delete Save (Slot), and the save stores a timestamp and optional saved transform (position).

Manual approach — your own Save Game

If you already have a save system, just call Save Stats (Target) → gives you an array of Vital Save Data to store however you like, and Load Stats (Target, SaveData) → restores it. Values are automatically clamped to each stat's Min/Max, and runtime max-value upgrades are restored so bars read correctly.

17Multiplayer#

Character Vitals is server-authoritative and replicates automatically.

1. In your Data Asset, set Component Mode to Multiplayer.
2. That's it. The server owns the real stat values and replicates them to all clients. The HUD on each client updates from the replicated data.

Best practices:

• Always change stats on the server (e.g. Modify Stat, Deal Damage). Calling them on a client alone won't be authoritative.
• Use the events (Section 9) on clients to play local effects — they fire when replicated values arrive.
• Use Single Player mode for solo games to avoid all replication overhead.

18Performance tips#

• Tune Update Interval per character type. 1.0s for the player feels responsive; set distant NPCs to 2.0–10.0s.
• Use Lightweight Mode for NPCs that only need basic decay/regen. Enable Lightweight Mode on the component (or call Set Lightweight Mode) to skip influences, conditions, sounds and screen effects.
• Pause off-screen actors. Call Pause (and later Resume) to stop the update loop entirely — zero CPU while paused. Great for stasis/streaming.
• Disable unused features. Leave Passive Conditions, Influences and Day/Night Config empty/off when not needed — they have zero overhead when unused.
• Hide HUDs you don't need. Only the player typically needs a widget; NPCs usually set Show In Widget off or skip the Widget Class.

19Complete Blueprint function reference#

All of these are in the Vitals Function Library — searchable in any Blueprint. Target is the Actor that owns the Vital Signs Component.

Component

• Get Vitals Component (Target) — get the component.
• Has Vitals (Target) — does it have one?

Modify

• Modify Stat (Target, StatName, Amount)
• Set Stat (Target, StatName, Value)
• Fill Stat / Drain Stat (Target, StatName)
• Fill All Stats / Drain All Stats (Target)
• Increase Stat Max (Target, StatName, Amount) — permanent max increase (level-ups).
• Set Stat Max (Target, StatName, NewMax)

Query

• Get Stat Value / Get Stat Percent (0–1) / Get Stat Max / Get Stat Min
• Get Stat Missing (Max − Current)
• Is Stat Critical / Is Stat Depleted / Has Stat
• Is Any Stat Critical / Is Any Stat Depleted
• Get All Stats / Get Stat Definition

Combat

• Deal Damage (Instigator, Target, Damage, StatName) → returns died?
• Heal (Target, Amount, StatName)
• Kill (Killer, Target, StatName)
• Can Afford (Target, StatName, Cost) / Spend (Target, StatName, Cost)

Modifiers

• Apply Modifier / Remove Modifier / Remove All Modifiers
• Get Modifiers / Has Modifier / Get Modifier Count

Control

• Lock Stat / Unlock Stat / Is Stat Locked — invulnerability, etc.
• Pause / Resume
• Set Lightweight Mode / Is Lightweight Mode

Conditions

• Is Condition Active / Get Active Conditions
• Show Condition / Hide Condition / Show Timed Condition

Rates

• Set Decay Rate / Set Regen Rate
• Reset Rates / Reset All Rates
• Get Decay Rate / Get Regen Rate

Over Time

• Start Regen (Target, StatName, Rate, StopAtValue) / Stop Regen
• Start Decay (Target, StatName, Rate, StopAtValue) / Stop Decay
• Is Regen Active / Is Decay Active

Day / Night

• Set Time Of Day / Get Time Of Day / Is Daytime
• Get Sun Angle / Get Sun Rotation / Get Sun Height

HUD

• Get HUD / Show HUD / Hide HUD / Toggle HUD / Is HUD Visible
• Add HUD / Remove HUD

Save / Load

• Save Stats (Target) → save data array
• Load Stats (Target, SaveData)

Debug

• Show Debug / Hide Debug / Toggle Debug — on-screen overlay (dev builds).

20Troubleshooting (FAQ)#

21Support#

• Documentation: seoulmediastudio.com/docs/character-vitals
• Created by: Seoul Media Studio — seoulmediastudio.com

Open the included Blueprints in L_VitalsDemo for working, copy-pasteable examples of every feature described here. Happy developing!