6. Progression

In short: Progression is how your heroes grow. Every game has levels (stats from the class, abilities at their unlock levels). On top you choose one of three systems: Classic (levels only), Classic + Points (the player spends attribute and ability points) or Classic + Growth Board (the player opens nodes on a board). Four optional sources add more ways to learn: equipment mastery, teachers, learning from enemies and use growth. Everything is data, and generators fill it in from your classes.

6.1 Basics

6.1.1 Levels and the three systems

In every system, a class still learns its abilities at their levels and its stats still grow with each level (Characters and party). The other two systems add a layer the player builds.

Points are never lost: a character's available points are computed from its level and its plan (level grants + bonus points − spent points), so an old save, or a plan you rebalanced later, always gets the right amount. Spending is final unless your game allows a respec.

6.1.2 First working example

1. Open the Studio and go to 1. Game foundation → Progression system (or Project Settings → RPG Saga Engine → Progression Systems). Pick a system.
2. Classic + Points: nothing else is needed to try it. The starter hero classes come with a plan, and every other class uses the default plan (Default Plan).
3. Classic + Growth Board: open 2. Archetypes → Growth board, pick a class and press Generate Board. Open the result in the board editor and change anything you like.
4. Press Play, open the party menu, go to the Growth page and spend the points.

If the Growth page does not show, the game is using Classic. Pick another system, or let the player choose at New Game (see below).

6.1.3 Growth Plans

A Growth Plan (URSEGrowthPlan) belongs to a class (Class → Growth Plan) or to one character (Character → Growth Plan). A class without a plan uses Progression Systems → Default Plan. A plan holds:

• Point Grants: points per level for each currency (Progression.Points.*): At Start, Per Level, and Extra At Levels for milestones. The three built-in currencies are Progression.Points.Attribute, .Ability and .Board. Add your own currencies as tags under Progression.Points.
• Attributes (Classic + Points): the key attributes the player may raise. Per attribute: Value Per Point, Cost Per Point, Cost Increase Every N points by Cost Increase, Max Points and Max Points Per Level.
• Ability Catalog (Classic + Points): abilities the player can buy, each with Cost, Currency, Required Level, Prerequisites (abilities from any source) and story Conditions.
• Board: the class's Growth Board.
• Enemy Learning: rules for learning abilities from enemies (see below).

6.1.4 Growth Boards

A board is a set of nodes joined by edges. Each character starts on its start node (per character, per class, or the board's default) and can open any node next to an open one, if it has the points, the level and the story conditions.

Node kinds (ERSEGrowthNodeKind):

A node also has an Id, a Label, a Position, a Tier (0 common to 3 rare, drawn as a ring), a Cost, a Required Level, optional required class tags, a Region, and gate conditions and text.

Regions are themed parts of the board (offense, defense, magic, utility): nodes name their region, and the screen tints it and writes its name. Layout presets (ERSEGrowthLayoutPreset) arrange generated boards:

• Constellation: star clusters linked by long bridges (straight lines);
• Radial Wheel: spokes, rims and a sector per region (arcs);
• Tree / Roots: a trunk forking into a limb per region (curves);
• Grid Lattice: a spine with blocks above and below, right angles only;
• Hex Web: a hexagonal web with honeycomb regions, 60-degree angles;
• Auto: the preset for the class's archetype role (Role Layouts), or Fallback Layout.

Boards are clean by rule: no crossing edges, no overlapping nodes, no edge over a node (Progression Systems → Board → Layout Rules). Generated boards always pass. For boards you lay out yourself, Check Layout and asset validation list the problems.

Scope: Board Scope is Per Class (each class's plan names its board) or Shared (every character uses Shared Board, each from its own start node). Travel Cost Per Step makes each step from where the character stands to the node it opens cost extra points (0 = no cost).

Looks: each board names a Board Style (URSEGrowthBoardStyle): the words on screen (a "Constellation" of "Stars" paid in "Starlight" with an "Ignite" button, or "Roots", "Knots", "Sap" and "Grow", or "Circuit", "Sockets", "Charge" and "Wire"), colors per node kind (following the active UI style by default), node shapes, straight or curved edges, icons, glows and a layered backdrop. Three starter styles ship in /RPGSagaEngine/Data/Growth/Styles. Make your own to give your game its own identity.

The board editor: double-click a board. Add nodes from the right-click menu, draw links between nodes, move nodes freely, and edit the selected node in Details. The Issues tab lists unreachable nodes, missing abilities and other problems. Layout Preset generates the board again from its class in another preset.

In game: the player clicks a node (or presses Confirm) and a small menu opens next to it: Unlock with its cost, Details, Cancel. The member strip shows each member's portrait, name and points. Undo takes any step back for free while the page stays open.

6.1.5 Generators: content from your classes

The generators build balanced, editable progression from a class. The class's stat growth tells them what the class develops (its role), and its ability pool tells them what it can learn.

• Generate Point Tables (Generate Growth Point Tables): key attributes, points per level, prices and caps, and a catalog spread over the levels with learning paths.
• Generate Board (Generate Growth Board): a themed region per key attribute in the chosen layout preset (an entrance junction that forks into two rails, a loop, a side path on each rail, a level gate, the remaining abilities and the region's keystone), bridges between neighbouring regions, and the weakest abilities nearest the start.

They are deterministic: the same class, pool and seed always give the same result, so you can re-run them after changing the class, then edit by hand. The Studio fills the ability pool for you (abilities like the class's own) and uses the archetype's role (Role Emphasis) to favor the right stats. Starting values are in Progression Systems → Generator (Generator Defaults).

6.1.6 Equipment mastery

On a weapon or armor, add Mastery Abilities (an ability and the Points To Master). While the item is equipped the wearer can use those abilities. Every won battle gives mastery points (Mastery Points Per Victory plus Per Enemy, times the item's Mastery Rate). At the goal, the ability is learned for good and stays after the item is removed. The party menu shows the progress ("Riposte: 12 / 30"). The Studio's 3. Content → Weapon with mastery wizard makes such an item.

6.1.7 Teachers

A Teacher (URSETeacherData) lists offers. Each has the ability, the price (money, items, the learner's points), who may learn it (class tags or traits, level) and story conditions. An offer is hidden, or greyed out with the reason when Show When Locked is on, until its conditions hold. A teacher can also offer a respec for money.

• From a dialog: the effect Open Teacher opens the teacher's screen; Teach Ability gives one lesson; the condition Can Learn From Teacher checks the price first.
• The Studio's 3. Content → New teacher wizard makes one.

6.1.8 Learning from enemies

Add Enemy Learning rules to a class's plan, or let a trait do it for any character (Progression Systems → Trait Learning). A rule has a trigger, a chance per battle, an optional list of abilities or ability types, and whether the character must survive and the battle be won:

• Hit By: the character was damaged or affected by the ability.
• Seen: any enemy used it in the battle.

Never Learnable Types keeps attacks and monster-only actions out. Switch the whole feature off with Enable Enemy Learning.

6.1.9 Use growth

Turn on Progression Systems → Enable Use Growth. Abilities then rank up with use. Each ability uses its own Use Growth curve (URSEUseGrowthCurve) or the Default Use Growth curve: ranks reached after a number of battle uses, each with its power (percent of base) and cost (percent of base). The battle menus show the cost the character really pays. Exclude an ability with Exclude From Use Growth (summons, item abilities and story actions are never ranked). The starter set has DA_UseGrowth_Standard.

6.1.10 Respec and free undo

Respec Mode (Progression Systems → Respec):

A respec gives back the points spent on attributes, catalog abilities and board nodes, minus Respec Point Penalty (0.1 by default: 10%, rounded, per currency; 0 gives everything back). The Growth page says exactly how much before the player confirms. Lessons from teachers, mastery and use ranks stay.

Free undo: while the Growth page stays open, the player can take back the last steps (raise, learn, unlock, Auto) for free, one at a time, up to Max Undo Steps (default 50). Closing the page makes them final.

6.1.11 Choosing the system per game, or letting the player choose

The system is part of the rules, so each foundation preset sets its own (Game Foundation → Progression → Progression System). Turn on Player Chooses At New Game to ask the player when a new game starts. The offered systems (New Game Choices, all three when empty), their names and descriptions, and the question text are in the settings.

6.2 How it works

6.2.1 Points, never stored as available

Available(Currency) = LevelGrants(Level) + BonusPoints − SpentPoints

Level grants come from the character's plan (FRSEPointsGrant::GetTotalAt(Level)). Bonus points come from battles, story effects and items. The state per character (FRSECharacterGrowth) records bonus points, spent points (and the share a respec keeps), attribute points, bought abilities, unlocked node ids and the current node (for travel cost), mastery progress, ability use counters, respec count and points lost to respecs. It is saved inside the Party section (FRSEPartyState::Growth), so co-op replicates it with the party. Only the undo journal of the open page is not saved.

6.2.2 What each system adds to a unit

For a battle unit or the party menu, the progression contributes:

• stats as an attribute source (attribute points times Value Per Point, board Stat Boost and Keystone modifiers) in the usual order of operations;
• abilities (bought catalog abilities, board Ability and Passive nodes, mastered or learned abilities) alongside class, equipment and Pact abilities;
• ranks for use growth (power and cost multipliers) applied when the unit is built.

After each won battle, RSEGrowth::ProcessBattle awards battle points (Battle Points rewards, default 5 board points per victory), mastery points, enemy-learned abilities and use counters, and returns the rewards for the results screen.

6.2.3 Commands

Every spend is a party command that works for the host and for guests: Allocate Attribute Points, Buy Growth Ability, Unlock Growth Node, Respec Character, Learn From Teacher, Auto Allocate Growth, Undo Growth Step, Clear Growth Undo, Set Progression System and Award Growth Points. A guest builds only the character it plays (Co-op Rules → Guest Equipment); choosing the system and awarding points are host-only. Guests (temporary members) keep a fixed build.

6.2.4 Automatic allocation

Characters nobody builds by hand (AI-controlled members, autoplay) spend their points with the Allocation Policy. After each battle and level-up, AI-controlled members spend automatically (Auto Allocate AI Controlled). The Auto button on the Growth page uses the policy too. The battle simulator, Balance My Campaign and the Progression Designer simulate party members with a typical build for the system in use (every point spent by the policy, battle points estimated with Simulated Victories Per Level and Simulated Enemies Per Victory), so balance stays valid whichever system you choose.

6.2.5 The Progression Designer

"Does my game have the pace I want?" The Progression Designer plays your whole campaign in the battle simulator with a standard party and shows where the party ends up under- or over-leveled, where battles drag on, where players would have to grind and where battles are too easy. An advisor proposes values (experience curve, enemy experience, enemy and class stat growth) and applies them only when you confirm, with undo.

1. Make one progression zone per chapter (URSEProgressionZoneData): enemy level range, expected battles, target entry and exit levels, regular encounters, key battles.
2. Make a campaign (URSECampaignProgressionData): the zones in order, the standard party, targets and simulation settings.
3. Open RPG Saga Engine → Configurator → Tools → Progression Designer, pick the campaign, press Run projection, read the charts, then Run advisor. Tick the recommendations to keep and press Apply selected.

Zones also scale enemy levels in the game itself: a regular battle gets enemies at the party's level (plus offsets) inside the zone's range. Those rules (Scale Enemy Levels, Party Level Source, Enemy Level Offset, Overlevel Bias, Enemy Level Variance) are on the Progression page. The starter set includes a finished example, DA_Campaign_Starter. Full details are in docs/product/progression-designer.md.

6.3 Key classes and assets

6.4 Settings

Project Settings → RPG Saga Engine → Progression Systems (a rules-profile section). The properties that matter most, with their defaults:

Related pages: Progression (maximum level, experience curve, enemy levels), Growth UI (the Growth page and board screen), Progression Designer (Power Samples, default 20) and, in the editor, Progression Tools (value ranges the AI schema uses). Full lists are in Appendix B.

Data fields: Class / Character → Growth Plan; Ability → Use Growth, Exclude From Use Growth; Equipment → Mastery Abilities, Mastery Rate.

6.5 Blueprint usage

All nodes are in the category RPG Saga → Progression (hidden World Context). Reading:

Get Progression System, Get Available Growth Points (Character, Currency), Get Growth Currencies, Get Allocated Attribute Points, Is Growth Node Unlocked, Get Growth Node Cost, Get Growth Plan, Get Growth Board, Get Mastery Points, Get Ability Rank, Get Growth Options, Can Learn From Teacher, Describe Growth Result.

Changing (each returns a Growth Result: Ok, Invalid Arguments, Not Member, Wrong System, Not Available, Not Enough Points, Cap Reached, Missing Prerequisite, Level Too Low, Conditions Not Met, Already Owned, Not Adjacent, Respec Not Allowed, Missing Item, Not Enough Money, Nothing To Reset, In Battle, Guest Character):

Allocate Attribute Points, Buy Growth Ability, Unlock Growth Node, Respec Character, Learn From Teacher, Auto Allocate Growth, Set Progression System, Award Growth Points.

Editor tools (category RPG Saga → Progression → Generator): Get Growth Generator Defaults, Generate Growth Point Tables, Generate Growth Board, Get Growth Board Problems, plus fill-level estimates.

Example 1: give board points as a quest reward.

1. In your reward graph, Award Growth Points (Character = DA_Char_Hero, Currency = Progression.Points.Board, Amount = 3).
2. Branch on the result: anything other than Ok can be reported with Describe Growth Result.

In data, use the effect Award Growth Points in the quest's reward list instead.

Example 2: a custom "Spend all" button.

1. Auto Allocate Growth (Character).
2. Get Available Growth Points (Character, Currency = Progression.Points.Attribute) to refresh the label.

Story effects and conditions (data): Open Teacher, Teach Ability, Award Growth Points; Progression System Is, Has Growth Node, Can Learn From Teacher.

6.6 C++ usage

Read points with the RSEGrowth rules, and spend them through the library, which sends the matching party command (so it works for the host and for guests):

#include "Growth/RSEGrowth.h"
#include "Growth/RSEGrowthTags.h"
#include "Growth/RSEBlueprintLibrary_Growth.h"
#include "Characters/RSEPartySubsystem.h"
#include "Core/RSEGameplayTags.h"

void SpendOnAttack(UGameInstance* GI, const URSECharacterData& Hero)
{
	URSEPartySubsystem* Party = GI->GetSubsystem<URSEPartySubsystem>();
	const int32 Points = RSEGrowth::GetAvailablePoints(
		Party->GetState(), Hero, RSEGrowthTags::Points_Attribute);
	if (Points <= 0)
	{
		return;
	}
	// Sends the Allocate Attribute Points command and returns its result:
	URSEBlueprintLibrary_Growth::AllocateAttributePoints(GI, &Hero, RSEGameplayTags::Stat_Attack, 1);
}

A custom allocation policy (deterministic, so simulations stay reproducible):

UCLASS()
class UMyPolicy : public URSEGrowthAllocationPolicy
{
	GENERATED_BODY()
public:
	virtual int32 ChooseOption_Implementation(const URSECharacterData* Character, int32 Level,
		const TArray<FRSEGrowthOption>& Options) const override
	{
		// Prefer abilities over attributes; -1 stops spending.
		for (int32 Index = 0; Index < Options.Num(); ++Index)
		{
			if (Options[Index].Kind == ERSEGrowthOptionKind::Ability) { return Index; }
		}
		return Options.IsEmpty() ? -1 : 0;
	}
};

Set it in Progression Systems → Allocation Policy Class. The same class works as a Blueprint child (override Choose Option).

6.7 Advanced

• Your own currencies. Add a tag under Progression.Points (for example Progression.Points.Mastery), give it a Point Grant in a plan, and price nodes or catalog entries in it. Battle rewards (Battle Points) can award it, optionally only for one system (Only For System).
• Rules profiles. The system is part of the rules, so a profile can switch it per chapter or per game mode. Progression Systems is a profile section.
• Importing AI-written progression. The progression schema (rse.progression/1) describes a class's plan, board, mastery items, teachers and enemy learning in one JSON file. Configurator → Tools → Content Import → Export AI pack writes a prompt generated from your project; the importer checks the answer, shows a dry run and never deletes anything or changes the plugin's own assets. See docs/product/progression-ai-schema.md and Editor tools.
• Command line. UnrealEditor-Cmd <Project>.uproject -run=RSEProgression -Campaign=<asset> [-Advisor] [-Out=<dir>] [-Set=ExperienceBase=12,...] runs the Progression Designer headless (the -Set option projects what-if values without changing anything). -run=RSEContentImport -Source=<folder> [-DryRun] imports progression files.
• Performance. Boards are plain data. The board screen reads the style and the node list only while the Growth page is open.
• Networking. The state lives in the Party section; commands are validated by the host. Undo is also checked by the host.
• Balance. After changing a plan, re-run the Progression Designer: the power curves show whether a system pulls ahead too fast. Keep gates for story beats (a flag) and pacing (a level) so players cannot rush a branch.

6.8 Troubleshooting

6.9 See also

• Characters and party
• Game foundation and archetypes
• Abilities and statuses
• Items, inventory and economy
• Battle fundamentals for the battle simulator and Balance My Campaign
• Product pages: docs/product/progression.md, docs/product/progression-designer.md, docs/product/progression-ai-schema.md; design notes docs/design/progression-systems.md, docs/design/progression-designer.md.