Type-Safe Interface - ISimpleAttributeDataSource for consistent integration
JSON Import/Export - Share templates and configurations
Validation - Automatic fixing of invalid configurations
Performance - Cached collections and optimized lookups
Ultimate Ready - Designed to work seamlessly with the Influence, Modifier, and Character Template systems in Simple Attribute Forge Ultimate
Installation
Get Simple Attribute Forge installed and ready to use in your Unity project.
System Requirements
Unity: 2021.3 LTS or newer
Platform: All platforms supported
.NET: .NET Standard 2.1
Installation Complete! The "Window → Simple Attribute Forge" menu should now be available.
Quick Start
Create your first complete attribute system in under 5 minutes! This guide shows the current workflow for the modern Simple Attribute Forge system.
4-Step Creation Process
1Open the Attribute Data Wizard
Navigate to Window → Simple Attribute Forge → Attribute Data Wizard
2Configure Your Attribute System
Set up basic information and add your attributes
3Generate Code Files
Create enum, runtime class, and ScriptableObject automatically
4Add to GameObject
Attach generated component and start using your attributes
Congratulations! You now have a fully functional attribute system with the modern three-tier value architecture. Always use totalValue for gameplay logic!
Wizard Guide
Complete guide to the 4-step attribute generation wizard that creates type-safe, feature-rich attribute systems with modern three-tier architecture.
What the Wizard Generates
Three-Tier Value System
Each attribute has baseValue, formulaBonus, modifierBonus, and calculated totalValue for clean separation of concerns.
Type-Safe Interface
Generated components implement ISimpleAttributeDataSource for consistent integration across your project.
Automatic Regeneration
Coroutine-based regeneration system for Vital attributes with configurable delays and rates.
Ultimate Ready
Built-in support for Simple Attribute Forge Ultimate's Influence System through formulaBonus separation, and Modifier System through modifierBonus.
Runtime Usage
Complete guide for using generated attribute systems in your game with correct patterns and best practices.
Critical: Three-Tier Value System
Understanding this is crucial for proper gameplay programming!
Every attribute uses a three-tier value architecture:
// ALWAYS use totalValue for gameplay calculations
float damage = strength.totalValue * weaponMultiplier;
float defense = armor.totalValue;
bool canCastSpell = mana.currentValue >= spellCost;
// ModifyValue() - For gameplay changes (triggers regeneration)
health.ModifyValue(-damageAmount); // Take damage
mana.ModifyValue(-spellCost); // Cast spell
// baseValue - For permanent upgrades
strength.baseValue += 2; // Permanent stat increase
Common Mistakes: Never use baseValue for gameplay (misses bonuses!), never modify formulaBonus manually, and don't use the old .value property.
Base Demo Scene
An interactive demo showcasing core attribute features with three panels: Character Stats, Stat Checks, and Combat Simulation.
Quick Setup
1Open the Demo Scene
Navigate to Simple Attribute Forge/Base/FreeDemo/BaseDemo.unity
2Hit Play
The demo is fully self-contained - creates all attributes from code at runtime
Three Panels
Character Stats
8 attributes (HP, Mana, Stamina + STR, DEX, INT, DEF, LCK) with real-time regeneration bars and damage/heal/rest buttons.
Stat Checks
Random challenges testing your stats. Train to permanently increase stats or drink potions for temporary boosts via modifierBonus.
Combat Sim
Auto-battle between Player and Goblin. Demonstrates attribute interaction patterns with STR-based damage and DEF-based mitigation.
Import/Export System
Share, backup, and create attribute configurations with JSON workflows.
Export Features
Export your attribute configurations as comprehensive JSON files that include all settings, validation rules, and metadata for easy sharing between projects.
Import Features
Import attribute configurations from JSON files to quickly set up new systems or share templates with team members.
Troubleshooting
Common issues and solutions for Simple Attribute Forge. Updated for the modern three-tier value system.
Most Common Issues
Values Not Updating Correctly
// WRONG - Common mistakes
float damage = strength.baseValue * weapon; // Missing bonuses!
float health = healthAttr.value; // Property doesn't exist
strength.formulaBonus += 10; // Will be overwritten!
// CORRECT - Modern patterns
float damage = strength.totalValue * weapon; // Includes all bonuses
float health = healthAttr.currentValue; // For Vitals
float maxHealth = healthAttr.totalValue; // For max values
Regeneration Not Working
Checklist:
Behavior Type: Must be set to "Vital"
Can Regenerate: Must be enabled (true)
Damage Method: Use ModifyValue(), not SetValue()
Most Common Fix:
Many issues are resolved by updating code from the old .value property to the modern three-tier system using .totalValue, .currentValue, and .baseValue appropriately.
API Reference
Complete reference for all Simple Attribute Forge classes, methods, and interfaces.
SimpleRuntimeAttribute
Properties - Core Values
// Three-Tier Value System
public float baseValue { get; set; } // Persistent value (saved with character)
public float formulaBonus { get; set; } // Calculated from influence formulas
public float modifierBonus { get; set; } // Temporary effects (buffs/debuffs)
public float totalValue { get; } // CALCULATED: base + formula + modifier
// For Vitals only
public float currentValue { get; set; } // Actual HP/MP within max bounds
Critical: Always use totalValue for gameplay logic (damage calculations, etc.). Use baseValue only for save/load and formula inputs.
About Simple Attribute Forge
Thank you for using Simple Attribute Forge! This system represents countless hours of development to create a robust, professional-grade attribute system for Unity developers.
Design Philosophy
Code Generation Over Frameworks - Generate clean, readable code instead of complex abstractions
Performance First - Cached lookups, minimal allocations, optimized for runtime efficiency
Future-Proof Architecture - Three-tier system designed for extensibility and Ultimate integration
Ultimate Version Available: Simple Attribute Forge Ultimate adds the Influence System (formula-based attribute relationships), Modifier System (buff/debuff framework), and Character Template System (class-based starting attributes).