Godot Rpg Stats

# base_stats_resource.gd
# Core data container for RPG attributes
class_name BaseStats extends Resource

# EXPERT NOTE: Using a Resource for base stats allows for 
# "Template" creation in the Inspector (e.g., GoblinStats, BossStats).

@export_group("Primary Attributes")
@export var strength: int = 10
@export var dexterity: int = 10
@export var intelligence: int = 10

@export_group("Derived Scaling")
@export var hp_per_strength: float = 5.0
@export var mp_per_intelligence: float = 3.0

func get_max_hp() -> int:
	return int(strength * hp_per_strength)

func get_max_mp() -> int:
	return int(intelligence * mp_per_intelligence)

# damage_formula_handler.gd
# Centralized logic for combat math
class_name DamageFormula extends RefCounted

# EXPERT NOTE: Move complex math out of Node scripts and into 
# RefCounted classes to keep your core scripts clean.

static func calculate_damage(attacker: StatsComponent, defender: StatsComponent) -> int:
	var atk = attacker.get_attribute("strength")
	var def = defender.get_attribute("dexterity") # Dodge chance
	
	# Simple formula: Atk - Def (Clamped)
	var raw = atk - (def * 0.5)
	return int(max(raw, 1.0))

# dynamic_stat_label_sync.gd
# UI hook for reactive stat displays
extends Label

# EXPERT NOTE: UI should listen for stats_recalculated 
# rather than polling in _process.

@export var stats: StatsComponent
@export var target_attribute: String = "strength"

func _ready():
	if stats:
		stats.stats_recalculated.connect(_update_display)
		_update_display()

func _update_display():
	text = "%s: %d" % [target_attribute.capitalize(), stats.get_attribute(target_attribute)]

# exp_progression_resource.gd
# Data-driven level up curve
class_name ExpProgression extends Resource

@export var base_exp: int = 100
@export var growth_factor: float = 1.2

func get_required_exp(level: int) -> int:
	return int(base_exp * pow(growth_factor, level - 1))

# level_up_system.gd
# Orchestrating level up benefits
class_name LevelUpSystem extends Node

@export var stats: StatsComponent
@export var curve: ExpProgression

var current_exp: int = 0
var level: int = 1

func add_exp(amount: int):
	current_exp += amount
	var req = curve.get_required_exp(level)
	if current_exp >= req:
		_level_up()

func _level_up():
	level += 1
	# Apply permanent "Level Up" modifier
	var mod = StatusEffectData.new()
	mod.attribute = "strength"
	mod.value = 2.0
	mod.duration = 0 # Permanent
	stats.apply_modifier(mod)
	print("LEVEL UP! Now Level ", level)

# skills/rpg-stats/code/modifier_stack_stats.gd
extends Node

## RPG Stats Expert Pattern
## Implements Reactive Updates and Additive/Multiplicative Modifiers.

signal stat_changed(stat_name: String, new_value: float)

# 1. Base Stat vs Modifier Pattern
# Expert logic: Treat Stats as Resources to allow easy sharing.
class Stat:
    var base_value: float = 0.0
    var modifiers_add: float = 0.0
    var modifiers_mult: float = 1.0 # 1.0 = 100% (No change)
    
    func get_total() -> float:
        # Standard RPG Formula: (Base + Additions) * Multipliers
        return (base_value + modifiers_add) * modifiers_mult

var stats: Dictionary = {
    "strength": Stat.new(),
    "agility": Stat.new(),
    "max_health": Stat.new()
}

func add_modifier(stat_name: String, amount: float, is_multiplier: bool = false) -> void:
    # 2. Modifier Stacking Logic
    if not stats.has(stat_name): return
    
    var stat = stats[stat_name]
    if is_multiplier:
        stat.modifiers_mult += amount
    else:
        stat.modifiers_add += amount
        
    # 3. Reactive Stat Updates
    # Notify UI components ONLY when specific stats change.
    stat_changed.emit(stat_name, stat.get_total())

func get_stat(stat_name: String) -> float:
    return stats[stat_name].get_total() if stats.has(stat_name) else 0.0

## EXPERT NOTE:
## Use 'Exponential XP Formulas': For leveling, use 
## 'floor(100 * pow(level, 1.5))' to create a smooth difficulty curve.
## For 'rpg-stats', implement 'Derived Stat Calculation': 
## 'attack_power = get_stat("strength") * 1.5 + get_stat("agility")'. 
## Hook this into the 'stat_changed' signal to update child stats 
## whenever a parent stat is modified.
## NEVER allow direct modification of 'max_health' variable; 
## always use the 'add_modifier' protocol to prevent 'Value Leakage'.

# persistent_character_stats.gd
# Saving and loading character progression
extends Node

@export var stats: CharacterStats # Custom Resource

func save_stats():
	ResourceSaver.save(stats, "user://player_stats.tres")

func load_stats():
	if ResourceLoader.exists("user://player_stats.tres"):
		stats = load("user://player_stats.tres")

# resource_stat_inheritance.gd
# Specialized stat containers (e.g., Elemental Resistances)
class_name ElementalStats extends BaseStats

@export var fire_res: float = 0.0
@export var ice_res: float = 0.0

func get_res(element: String) -> float:
	return get(element + "_res")

# stat_modifier_stacking.gd
# Preventing modifier bloat and conflicts
extends Node

# EXPERT NOTE: Use a unique ID or Name check if you don't 
# want the same buff to stack multiple times.

func apply_unique_buff(stats: StatsComponent, mod: StatusEffectData):
	for existing in stats.modifiers:
		if existing.name == mod.name:
			# Refresh duration instead of adding new
			return
			
	stats.apply_modifier(mod)

# skills/rpg-stats/scripts/stat_resource.gd
extends Resource

## Stat Resource Expert Pattern
## Modular stat system with modifier stacks, dirty flags, and derived stat support.

class_name StatResource

signal value_changed(new_value: float, old_value: float)
signal modifier_added(modifier: StatModifier)
signal modifier_removed(modifier: StatModifier)

@export var base_value: float = 10.0:
	set(v):
		var old = base_value
		base_value = v
		_dirty = true
		value_changed.emit(value, get_value_from_base(old))

var _modifiers: Array[StatModifier] = []
var _cached_value: float = 0.0
var _dirty: bool = true

var value: float:
	get:
		if _dirty:
			_recalculate()
		return _cached_value

func add_modifier(mod: StatModifier) -> void:
	_modifiers.append(mod)
	mod.changed.connect(_on_modifier_changed)
	_dirty = true
	modifier_added.emit(mod)
	value_changed.emit(value, _cached_value) # Value updates lazily, but signal needs current

func remove_modifier(mod: StatModifier) -> void:
	if mod in _modifiers:
		_modifiers.erase(mod)
		mod.changed.disconnect(_on_modifier_changed)
		_dirty = true
		modifier_removed.emit(mod)
		value_changed.emit(value, _cached_value)

func get_value_from_base(base: float) -> float:
	# Recalculate hypothetical value
	var v = base
	for mod in _modifiers:
		if mod.type == StatModifier.Type.ADD:
			v += mod.value
	for mod in _modifiers:
		if mod.type == StatModifier.Type.MULTIPLY:
			v *= mod.value
	return v

func _recalculate() -> void:
	_cached_value = get_value_from_base(base_value)
	_dirty = false

func _on_modifier_changed() -> void:
	_dirty = true
	value_changed.emit(value, _cached_value)

# Inner class for easy portability
class StatModifier extends Resource:
	enum Type { ADD, MULTIPLY }
	signal changed
	
	@export var type: Type = Type.ADD:
		set(v): type = v; changed.emit()
	@export var value: float = 0.0:
		set(v): value = v; changed.emit()
	@export var source: Variant # Optional reference to source weapon/buff

## EXPERT USAGE:
## @export var strength: StatResource
## strength.add_modifier(sword_mod)
## print(strength.value)

# stats_component_reactive.gd
# Orchestrator for dynamic stat calculation
class_name StatsComponent extends Node

# EXPERT NOTE: The final value is calculated "Just-In-Time" 
# to ensure all active modifiers are correctly applied.

signal stats_recalculated
signal hp_changed(current: int, max: int)

@export var base: BaseStats
var modifiers: Array[StatusEffectData] = []

var current_hp: int = 0

func _ready():
	if base:
		current_hp = base.get_max_hp()

func get_attribute(attr_name: String) -> float:
	var val = base.get(attr_name) as float
	
	# Apply additive modifiers first
	for mod in modifiers:
		if mod.attribute == attr_name and mod.type == StatusEffectData.Type.ADDITIVE:
			val += mod.value
	
	# Then apply multipliers
	for mod in modifiers:
		if mod.attribute == attr_name and mod.type == StatusEffectData.Type.MULTIPLICATIVE:
			val *= mod.value
			
	return val

func apply_modifier(mod: StatusEffectData):
	modifiers.append(mod)
	stats_recalculated.emit()
	
	if mod.duration > 0:
		get_tree().create_timer(mod.duration).timeout.connect(
			func(): remove_modifier(mod)
		)

func remove_modifier(mod: StatusEffectData):
	modifiers.erase(mod)
	stats_recalculated.emit()

# status_effect_data.gd
# Data definition for buffs and debuffs
class_name StatusEffectData extends Resource

# EXPERT NOTE: Defining effects as Resources makes them 
# strictly data-driven and easy to serialize/save.

enum Type { ADDITIVE, MULTIPLICATIVE, OVERRIDE }

@export var name: String = "Effect"
@export var type: Type = Type.ADDITIVE
@export var attribute: String = "strength"
@export var value: float = 0.0
@export var duration: float = 5.0
@export var icon: Texture2D