View Categories

Quest Manager

19 min read

Quest Manager #

Quest system #

Introduction #

The Quest System is a modular framework designed to manage and track all player-driven missions and objectives within the game world.
It supports a wide range of quest types — from main storyline arcs to optional side activities — and provides a data-driven structure for defining quest information, stages, objectives, and rewards.

This documentation will guide you through every part of the system, including:

  • Quest Data Structure – how quests are defined using DataTables and structs.
  • Quest Flow – how stages, objectives, and states progress over time.
  • Enums and Conditions – how different quest types, statuses, and triggers function.
  • Rewards and Integration – how XP, items, and reputation are applied upon completion.

Whether you’re creating narrative-driven main quests or repeatable side missions, this documentation explains how to configure, expand, and fully utilize the system to build rich, reactive gameplay experiences.

Assigning a quest data table #

In the gamestate class, click on the AC_GameState_TagMapper_Quests you previously added. Within the details panel you will find Linked Quest Table. This is the data table the gamestate will use for quests.

Quest data table overview #

The core of the system runs through a data table called “DT_Quests”, above shows the file path you can take to access the data table. The data table uses the structure “Struct_Quests” Which is two variables,

  • Variable Name : Quest info Variable Type: Struct Quest Info
  • Variable Name : Quest Stages Type: Struct Quest stages (array)

Here is an example of an example row of how to fill in Quest Info. Below will be an example of how to fill in Quest Stages.

To make this easier to follow, explanations of each structure will be headed as their own topic.

Structures explained #

Struct quest info #

Quest Name

Type: String

Purpose: The display name of the quest as shown to the player in the quest log or UI.

Usage:

  • Example: The Awakening, Defense of Stonefall, Clearing the Rebel Camp.
  • This is the primary title for identifying the quest in menus and objectives.

Quest Cover Image

Type: Texture 2D

Purpose: The visual image or thumbnail displayed alongside the quest name in the quest log or dialogue screens.

Usage:

  • Helps visually distinguish quests.
  • Example: A painting, screenshot, or concept art representing the quest.
  • Assign via imported textures (e.g., T_The_Awakening).

Quest Tag

Type: Gameplay Tag

Purpose: A unique identifier for the quest used internally by systems such as quest tracking, conditions, or triggers.

Usage:

  • Follows a hierarchy for organization (e.g., Quest.Main.TheAwakening.QuestOnlyExample).
  • Used by gameplay logic to reference or unlock quests dynamically.

Quest Type

Type: Enum Quest Type

Purpose: Defines the category or classification of the quest.

Usage:

  • Common examples:

Main: Core story questline.

Side: Optional but related to the world.

Used to visually separate quest types in the UI.

Can Quest Be Abandoned

Type: Boolean

Purpose: Determines whether the player can abandon or remove this quest from their quest log.

Usage:

  • True: The player can abandon the quest and retake it later.
  • False: The quest is mandatory or story-critical (e.g., main storyline missions).

Recommended Levels

Type: Struct Skill Level Range (Array)

Purpose: Indicates the suggested player level or range of levels for completing this quest. As this is a small struct, it can be explained here. It used a gameplay tag for the type of level assessed and an integer for the level needed.

Usage:

  • Example: Level 1-3 for an introductory quest.
  • Used for UI hints or to warn players if they are under/overleveled.
  • Can also be tied to scaling mechanics.

Introduction Story

Type: Text

Purpose: Provides a short narrative introduction or premise displayed when the quest begins.

Usage:

  • Used to establish context, tone, and objectives.
Example:

“You awaken in a dark, unfamiliar cave with no memory of who you are or how you got there. Strange markings glow faintly on the walls…”

Quest Chapter

Type: Enum Quest Chapter

Purpose: Groups the quest within a specific story chapter or act.

Usage:

  • Helps organize long questlines into acts or narrative phases.
Example: Prologue: The Awakening, Act 1: Rising Threat, Act 2: The Warfront.
  • Can also be used for progression gating.

Quest Prerequisites

Type: Gameplay Tag

Purpose: Defines which quest(s) must be completed before this one becomes available.

Usage:

Example: Quest.Main.ThePrologue.Completed.
  • Allows chaining and dependency between quests.
  • If empty, this quest is available by default.

Status Marker Options

Type: Struct Quest Status Marker Options

Purpose: Controls the visibility and behavior of quest markers and objective icons in the world or on the HUD.

Usage:

  • Determines whether quest locations, NPCs, or interactables show on the player’s map or compass.
  • Common parameters include:

Show marker when active only.

Hide after completion.

Custom icon selection.

Quest stage info #

Stage Name

Type: String

Purpose: The display name or title for this specific quest stage.

Usage:

  • Appears in the quest log and UI while the stage is active.
Example: Arm Yourself and Open the Gate, Defend the Village, Find the Missing Scout.
  • Helps the player track their current progress within the quest.

Stage Log In Progress

Type: Name

Purpose: The entry text shown in the quest log while this stage is currently active.

Usage:

  • Describes what the player should be doing.
Example: “Locate the weapon cache and prepare for battle.”
  • Updated when the stage becomes active.

Stage Log Completed

Type: Name

Purpose: The entry text shown in the quest log once this stage has been completed.

Usage:

  • Used to summarize the player’s achievement.
Example: “You have armed yourself and opened the gate to freedom.”
  • Replaces the “In Progress” text once objectives are fulfilled.

Reveal Markers In Objective Order

Type: Boolean

Purpose: Controls whether quest markers are revealed sequentially (one at a time) or all at once.

Usage:

  • True: Markers are revealed in order as each objective completes.

False: All objective markers are visible from the start.

  • Ideal for linear vs. open-ended quest designs.

Stage Objectives

Type: Struct Quest Objective Array

Purpose: Defines all the specific objectives that must be completed for this stage to progress.

Usage:

  • Each element in the array represents one task (e.g., “Collect 3 iron ingots”, “Talk to the blacksmith”).
  • The quest system monitors these objectives to determine when to advance to the next stage.

Stage Rewards

Type: Struct Quest Reward Array

Purpose: Defines the rewards given upon completing this stage.

Usage:

  • Can include XP, items, gold, or attribute increases.
Example: +100 XP, +1 Health Potion, or 250 Gold.
  • Used for incremental reward distribution across multi-stage quests.

Uses a Narrative to Structure State

Type: Boolean

Purpose: Determines whether this quest stage uses a Narrative Blueprint to control its flow and dialogue.

Usage:

  • True: A Narrative Blueprint will drive this stage’s logic (dialogue, branching, triggers).

False: The stage uses standard objective-based logic instead.

  • Enables integration with cinematic or dialogue-based quest progression.

Narrative to Use

Type: BP Narrative (Blueprint Reference)

Purpose: Specifies the Narrative Blueprint asset that handles this stage’s structured story events.

Usage:

  • Only relevant if Uses a Narrative to Structure State is set to true.
Example: BP_Narrative_AwakeningIntro.
  • Controls dialogue, cutscenes, or scripted interactions within the stage.

Quest objective struct #

Title

Type: String

Purpose: The display name or short description of this individual objective.

Usage:

  • Appears in the quest log and objective tracker.
  • Should clearly describe what the player must do.
Example: Collect 3 Wolf Pelts, Speak to the Village Elder, Defeat the Bandit Leader.

Objective Type

Type: Enum Quest Task

Purpose: Determines the functional category of the objective, defining how it is completed.

Usage:

  • The quest system uses this to know which event or condition to listen for.

Is Optional

Type: Boolean

Purpose: Specifies whether the objective is mandatory or optional for completing the stage.

Usage:

  • True: Optional — completion is not required to progress the quest.

False: Required — must be completed to advance.

  • Useful for bonus tasks or side achievements within a quest.

Target

Type: Gameplay Tag

Purpose: Identifies the entity, item, or actor the objective is focused on.

Usage:

  • Example:

Target.Creature.Wolf for a kill quest.

Target.Item.WolfPelt for a collection quest.

Target.NPC.Elder for a talk objective.

  • Used by the system to detect when the correct object or actor is interacted with.

Source

Type: Gameplay Tag

Purpose: Identifies where or from whom the objective originates.

Usage:

  • Commonly used for context in fetch or delivery quests.
Example: Source.NPC.Trader.Jon or Source.Location.ForestCamp.
  • Helps the system track the origin of quest interactions or deliveries.

Amount

Type: Integer

Purpose: The number of items, kills, or actions required to complete this objective.

Usage:

  • Example:

Collect 3 herbs.

Defeat 5 enemies.

  • The quest system decrements this count until completion is reached.

Show Quest Marker

Type: Boolean

Purpose: Controls whether this objective displays a quest marker in the world or on the minimap.

Usage:

  • True: Shows a visible marker to guide the player.

False: Keeps the objective hidden (useful for surprise or discovery-based goals).

  • Can also be toggled dynamically during the quest.

Quest Marker Tag

Type: Gameplay Tag

Purpose: Identifies which quest marker should appear for this objective.

Usage:

  • Example: Marker.NPC.Elder, Marker.Location.CaveEntrance, Marker.Item.HerbPatch.
  • Links the objective to the correct world or UI marker actor.
  • Only relevant when Show Quest Marker is enabled.

Quest reward struct #

Reward Type

Type: Enum Reward Type

Purpose: Defines the category or type of reward the player receives for completing this quest or stage.

Usage:

  • Determines how the system grants the reward (e.g., item, experience, currency).
  • Common examples include:

XP: Grants player experience points.

Item: Gives a specific item or resource.

Currency: Adds gold, silver, or another form of in-game money.

Reputation: Increases faction or community standing.

  • Used to trigger the correct reward-handling logic when the quest completes.

Amount

Type: Integer

Purpose: Specifies the quantity or numerical value of the reward to give.

Usage:

  • Represents how much XP, currency, or how many items the player should receive.
  • Example:

XP → 250

Currency → 100

Items → 3 (e.g., 3 healing potions)

  • Must match the expected unit for the selected Reward Type.

Reward

Type: Gameplay Tag

Purpose: Identifies the specific reward asset, item, or category to be granted.

Usage:

  • Defines what the player is rewarded with, based on the Reward Type.=
  • Examples:

Reward.Item.HealthPotion

Reward.Currency.Gold

Reward.XP.General

  • The tag ensures the system looks up the correct item or effect to apply.

Enumarations used #

Reward Type #

Adding New Reward Types #

To add a new reward type, first add the type to Enum_Reward_Types. For this Example we will create a hypothetical Reputation system. Navigate to the AC_QuestManager_Advanced blueprint. Once inside, go to the function “Give Reward”. This is what you should see.

Create the logic to add the reputation (or whatever the reward is for your desired system). Below is an example created for adding reputation.

Get Player Controller

  • Grabs the local PlayerController so we can reach systems attached to (or owned by) the player.

Get Reputation Manager

  • A helper function that returns your Reputation Component (manager) from the controller (or from the player’s pawn/character under the hood).
  • It also outputs Is Valid (bool) so we know if the component was found.

Branch (Is Valid?)

  • If the Reputation Manager wasn’t found, bail out (False).
  • If found (True), continue and apply the reward.

Break Struct Quest Reward

  • Splits the Quest Reward struct into its fields.
  • You’re using:

Amount (int) → how much reputation to grant (can be negative for penalties).

Reward (GameplayTag) → which reputation bucket to affect (e.g., Reputation.Type.Brave).

Apply Reputation (on the Reputation Manager)

Exec flows here only on the True path from the Branch.

Target (object pin): the Reputation Manager component you got earlier.

Amount: wired from the struct’s Amount.

Reputation to Apply: wired from the struct’s Reward tag.

Result: the Reputation system updates the specified faction/track for the player by the given amount.

Note: Reputation system is just an example, the “Apply Reputation” is an empty function, that would just lead to the logic in your own “Reputation” system.

As you can see, once this stage is complete you can now add reputation as a reward.

Quest Task Type #

Adding new Quest Type #

To add a new quest type add a new enumerator to Enum_Quest_Task_Type. From there open up the blueprint component AC_QuestManager_Advanced. Navigate to the event graph “Objective Listeners”. For this example I will add a quest type of “Survive Until”. Just like the “adding new reward type”, I will create an empty blueprint to showcase how it should look like.

Use an event dispatcher and bind it inside the objective listeners graph. This will track the progress of the quest. Once you have completed this, navigate to the event “Bind Objective Listeners” and add your new event to the list.

Quest Chapter #

Adding New Quest Chapter #

To add a new quest chapter, locate Enum_Quest_Chapter. Add a new Enumerator and name it what you desire. I will use “Chapter Example”. So with all that we have changed so far, we could create a new example row on the DT_Quest.

The Quest chapter now displays Chapter Example. This quest can not be started until Quest.Main.TheAwakening is completed.

The stage is “survive until”, so when the event dispatcher you created earlier fires. You will complete this stage. With the reward being 50 reputation to “brave”.

Quest States #

Active
 Purpose: Indicates that the quest is currently in progress.
Usage:

  • The player has accepted or started this quest.
  • Objectives and stages are being tracked in real-time.
  • Appears in the quest log as an active quest with visible objectives and progress markers.
  • The system listens for relevant gameplay events (kills, item pickups, interactions) while in this state.

Abandoned
 Purpose: Marks the quest as abandoned or cancelled by the player.
Usage:

  • The player chose to abandon the quest or failed to meet a required condition.
  • Objectives stop tracking, and quest markers are removed from the world/UI.
  • The quest can often be restarted or reacquired later (if the design allows).
  • Common for side or repeatable quests; main quests usually disable this option.

Completed
 Purpose: Signifies that all objectives and stages have been successfully finished.
Usage:

  • The player has completed the final stage or turned in the quest.
  • Rewards are granted (XP, items, gold, etc.), and the quest log marks it as complete.
  • Can trigger follow-up quests, unlockables, or narrative progression.
  • Often used as a prerequisite condition for other quests or world events.

Quest Status #

Available
 Purpose: The quest exists in the world but has not yet been accepted by the player.
Usage:

  • Displayed on NPCs, quest boards, or dialogue prompts as an available quest.
  • The player can view its description or requirements before deciding to accept it.
  • Often used to show quest icons (e.g., “!” markers) above NPCs.
  • Transitions to Ongoing once the player accepts the quest.

Ongoing
 Purpose: The quest has been accepted and is currently in progress.
Usage:

  • Active objectives are being tracked and displayed in the quest log.
  • The player must complete all listed objectives to advance.
  • May include intermediate stages or branching conditions.
  • Transitions to Ready To Turn In when all required objectives are complete.

Ready To Turn In
 Purpose: All objectives are complete, and the quest is awaiting submission to the relevant NPC or system.
Usage:

  • The player has met every requirement and can now return to the quest giver.
  • Triggers “turn-in” dialogue, cutscenes, or reward distribution logic.
  • Upon successful hand-in, the quest transitions to the Completed state.

Quest Type #

Main
 Purpose: Represents a core storyline quest essential to the game’s primary narrative progression.
Usage:

  • Advances the main plot or major world events.
  • Usually cannot be abandoned and must be completed to progress the story.
  • May unlock key areas, characters, or features.
  • Often includes cinematic sequences, voice acting, or major lore developments.
  • Displayed prominently in the quest log.

Side
 Purpose: Represents an optional quest that expands the world, characters, or gameplay but isn’t required for main story progression.
Usage:

  • Provides additional rewards such as gold, items, XP, or reputation.
  • Can often be abandoned and resumed later.
  • Used to enrich the world with smaller, self-contained stories.
  • May introduce unique gameplay mechanics or lore not tied to the main narrative.
  • Commonly found on notice boards, from NPCs, or through exploration.

Stage State #

Currently Active
 Purpose: Indicates that this quest stage is in progress and being tracked.
Usage:

  • The player is actively working on this stage’s objectives.
  • Objectives and quest markers tied to this stage are visible in the UI and world.
  • The quest system listens for any event or action related to this stage.
  • When all objectives in the stage are completed, it transitions to Is Completed.

Is Completed
 Purpose: Marks this stage as fully finished.
Usage:

  • All objectives and conditions in this stage have been successfully completed.
  • The system stops tracking this stage and unlocks the next one (if available).
  • Used to trigger rewards, dialogue updates, or progress to the next chapter in the quest.

Not Happened Yet
 Purpose: Indicates that this stage has not started or been triggered yet.
Usage:

  • The stage is pending activation — it will become Currently Active once all previous stages or prerequisites are met.
  • Useful for multi-stage quests where each stage is sequential.
  • Prevents premature tracking of objectives or markers before the stage officially begins.

Assigning the default quest #

Locate the player controller under the game state. Click on AC_QuestManager_Advanced. In the details panel find the category “Quests”, here you will see default Quests. Apply the gameplay tag of the quest you would like to start as the default. I have used the example quest from the previous chapter.

Understanding each quest type #

Deliver item #

Purpose: The player must bring a specific item to a designated NPC or location.

Example: Deliver a “Letter to the Village Elder.”

Triggered When: The required item is handed in or transferred to the target.

Note: Ensure Source Tag on DT_Quests, matches the Tag on DT_Items (Or your own inventory system)

This is taken From DT_Items and the tag for Iron_Hatchet is; Items.Equipment.Melee.Hatchet.Iron_Hatchet. So in DT_Quest you could have this an objective

Interact with actor #

Purpose: Requires the player to interact with a specific actor or object.

Example: Speak to the guard, open a gate, or inspect a corpse.

Triggered When: The player uses or interacts with the designated actor.

Kill #

Purpose: Eliminate one or more specific enemies.

Example: Defeat 5 wolves or slay the Bandit Leader.

Triggered When: The target actor(s) with the corresponding tag die with you being the instigator.

Adding tags to enemies #

There are three main ways of adding tags to enemies;

  • Add the gameplay tag to the blueprint, so all corresponding actors contain that tag.

On my zombie Blueprint, I have added the component AC_GameplayTags. From there, I have added the tag “Target.Enemy”

If I assign the tag “Target.enemy” to the target gameplay tag on the DT_Quest. Then anytime I kill a zombie, the quest will update the objective.

  • Manually adding tags to specific actors placed in the world.

Here is a zombie placed into the world. By clicking the actor and navigating to AC_Gameplay_Tags, a specific tag be assigned to instanced actors. By assigning the tag “Quest.Kill.Zombie” to only this enemy, stops the quest from being completed if the incorrect enemy is killed.

  • Dynamically adding tags.

For this example, I desired an enemy to spawn near a desired location when the player overlapped into the area. On overlap, the enemy spawns and adds a gameplay tag to the container. Meaning only that enemy that has spawned will have that specific gameplay tag.

Learn #

Purpose: The player must acquire a specific piece of knowledge, skill, or lore entry.

Example: Read a book, discover a recipe, or unlock a new crafting blueprint.

Triggered When: The player completes a “learn” event or gains the knowledge.

Obtain object #

Purpose: Obtain a particular item through any means (loot, trade, craft, etc.).

Example: Obtain a Steel Ingot.

Triggered When: The player’s inventory contains the specified item.

Craft #

Purpose: Craft a specific item using the crafting system.

Example: Craft an Iron Sword.

Triggered When: The crafting system registers the created item.

The top image has been taken from DT_Items and the bottom image is taken from DT_CraftingRecipies. Notice that both tags are identical. When adding the tag to DT_Quest, keep this tag consistent with the tags used in both of these tables.

Gather #

Purpose: Collect resources directly from the environment.

Example: Gather 10 Wood Logs or 5 Herbs.

Triggered When: The player harvests the specified resource type.

Steal #

Purpose: Acquire an item flagged as stolen, usually from NPCs or containers.

Example: Steal the Merchant’s Ledger.

Triggered When: The player takes an item from a protected source.

Find #

Purpose: Locate a hidden item, object, or area.

Example: Find the Lost Amulet in the ruins.

Triggered When: The player discovers or picks up the specified object.

Perform action #

Purpose: Requires performing a specific gameplay action or animation.

Example: Light a fire, ring a bell, or push a lever.

Triggered When: The system detects the defined action event.

Level up to #

Purpose: Reach a specific player or skill level.

Example: Reach Level 10.

Triggered When: The player’s experience or attribute level reaches the required threshold.

Use item #

Purpose: Use a specific item from inventory.

Example: Use a Health Potion or a Ritual Scroll.

Triggered When: The item’s “Use” event is executed.

Use skill #

Purpose: Use a defined skill (e.g., lockpicking, cooking, smithing).

Example: Use the Lockpicking skill to open the gate.

Triggered When: The skill activation event fires.

Use ability #

Purpose: Activate a particular ability or spell.

Example: Cast Fireball or use Stealth.

Triggered When: The ability system detects a matching activation.

Consume item #

Purpose: Consume a consumable item such as food or drink.

Example: Eat 3 Apples or Drink 1 Potion of Stamina.

Triggered When: The item is consumed and removed from inventory.

Discover area #

Purpose: Reach or enter a defined world location or region.

Example: Discover the Hidden Camp or Enter the Abandoned Mine.

Triggered When: The player enters the corresponding region volume.

To add a discoverable area, add in the blueprint actor BP_Trigger_DiscoverArea to your level. Depending if you want to manually add or dynamically add the area to your level will determine how you should apply the gameplay tag. Refer to adding tags to enemies to see more options. But the simplest way is to click on the BP_Trigger_DiscoverArea. Then assign the area tag that matches with your DT_Quests.

The Trigger box with the matching gameplay tag will now complete that objective.

Complete narrative #

Purpose: Finish a linked Narrative Blueprint or story sequence.

Example: Complete the conversation or cinematic sequence “The Awakening Intro.”

Triggered When: The referenced narrative finishes execution.

Trigger quests by events #

In this example we have used an event interact with a NPC. When interacting with this NPC it triggers the start of a quest. “Start Quest on Interact” is using the gameplay tag Quest.Main.DefenseOfStonefall.QuestMapExample which will be the identifier of the quest to trigger from DT_Quests.

What are your Feelings