Experience (XP) & Leveling System — Create a 2D RPG in Godot 4

Tech concepts & implementation overview (Godot 4: XP + Leveling for a 2D RPG)

Enemy XP reward via custom exported variable

• Each enemy scene defines an exported integer like experience_reward.
• Example: on defeat, the enemy awards 600 XP.

Custom signals for gameplay events

• Enemies create a custom signal, e.g.:
  • died(experience: int)
• When an enemy dies, it emits the signal and passes its XP reward.
• The player progression system is set up to listen for these signals.

Why progression state must not live on the Player node

The tutorial explains that:

• The player node is loaded/unloaded with maps (the player is a child of the current map scene).
• If level/experience were stored on the player, reloading a map would reset them (e.g., back to level 1 / XP 0), unless you apply hacky workarounds.
• It uses Godot’s Remote Scene Tree debugging to visualize local vs. remote nodes and confirm that reloading maps unloads player data.

Creating a persistent hierarchy: introduce a game scene

• A new GameScene becomes the main scene, loaded from:
  • Project Settings → Run
• The tutorial instantiates the map inside this game scene so the game scene persists across map loads.
• This is where persistent systems (like progression) can live.

Autoload/global persistent XP & level storage

• An autoload script named player_data is created.
• It stores:
  • level (int), initialized to 1
  • experience (int), initialized to 0
• It’s registered in:
  • Project Settings → Globals → Autoload
• A later tutorial is mentioned for saving/loading progression across game sessions.

Immutable progression rule data via global constants

• A global data script (e.g., level_data) contains constants for level XP thresholds.
• Thresholds are stored as an array (example: max level is 5).
• Indexing uses:
  • current_level - 1 (to match array indices)
• It also notes alternatives (e.g., math-based scaling) for very large max levels.

Player progression functions in the GameScene

The GameScene adds progression-handling functions:

• experience_gained(xp_amount: int)

  • If player_data.level is already at max level, it ignores XP.
  • Otherwise, it adds XP to player_data.experience.
  • It checks whether XP meets/exceeds the next threshold:
    • level_data.thresholds[level-1]
  • If enough XP is reached, it calls level_up().

• level_up()

  • Deducts the required threshold from XP so excess XP carries into the next level.
  • Includes a print/test to verify leveling works (no visuals yet).

Connecting enemy signals to the progression system

• In GameScene._ready():
  • Collect all nodes in the enemies group.
  • For each enemy, connect its custom died signal to experience_gained.
• The enemy scene uses an enemies group (set in the enemy scene inspector).

---

Extending progression: Level affects player stats + animations

Attack speed scales with level

• Removes the exported attack speed default from the player (attack speed becomes an internal value).
• Adds calculate_stats() when the player loads.
• Adds a custom level_up signal (emitted by GameScene logic) so the player can recompute stats when the level changes.

Encapsulation of math in a custom class

• Creates a custom helper script/class Equations with a static function, such as:
  • calculate_attack_speed()
• The function uses:
  • A base attack speed constant (noted as “not best practice” for large RPG class systems)
  • A steep curve: deducts 15% per level
  • Uses level - 1 so level 1 isn’t immediately penalized
• Key distinction:
  • Entities change state (player sets attack speed)
  • Helper classes compute values (equations returns results)

Recomputing attack speed on level-up

• calculate_stats() reads player_data.level.
• It sets the player’s attack speed using Equations.
• Debug output prints new attack speed values to confirm scaling (examples around level 1 → 3).

Visual feedback: speed up the attack animation

• Updates the player’s AnimationTree TimeScale based on the new attack speed.
• Computes a time factor:
  • base_attack_speed / current_attack_speed
• Sets that factor into the appropriate TimeScale node parameter.
• Workflow tip:
  • Use Inspector → right-click → Copy property path to reduce typos when setting long parameter paths.

---

Sources / main speakers

• Main speaker/source: the tutorial presenter (unspecified name) who leads the “RPG Essentials” series and explains Godot 4 XP/leveling implementation steps.