Quick Start - Simple Skill Forge

Your First Skill Database

This guide walks you through creating a complete skill database using the Skill Forge — from opening the wizard to using the generated database in your game code. The entire process takes about 5 minutes.

By the end, you will have:

A type-safe enum of all your skill codes
A ScriptableObject database with a custom inspector
Runtime-ready data you can query from any script

Prerequisites: Simple Skill Forge must be installed. See Installation if you have not done this yet. Unity 2021.3 or later is required.

Step 1: Setup

Open the Skill Forge wizard:

Window > Living Failure > Simple Skill Forge > Skill Forge

The wizard opens to Step 1: Setup. Configure these fields:

Database Name

Enter a name for your database, e.g., RPGSkills. This determines the generated class names:

Field	Example
Database Name	`RPGSkills`
Generated Enum	`RPGSkillsType`
Generated Database	`RPGSkillsDatabase`
Generated Editor	`RPGSkillsDatabaseEditor`

Namespace

Optionally set a namespace for the generated code. Leave blank if your project does not use namespaces.

Template

Select a genre template to pre-populate property definitions. For this walkthrough, choose ARPG — it provides a solid set of categories (Skill Type, Element, Target Type), flags (Is Passive, Is Ultimate), numerics (Mana Cost, Cooldown, Cast Time), and texts (Tooltip, Lore) at both skill-level and rank-level.

Tip: You can select None to start with a blank slate and define every property yourself. Templates are just a starting point — you can add, remove, or modify any property in Step 2.

Linked Databases

If you have companion packages installed (SAF, SIF, SEF, SQF), you can drag-and-drop their generated database assets here. This enables searchable dropdowns for cross-forge reference fields in Step 3 (e.g., selecting an item code from your SIF database instead of typing it manually).

For this walkthrough, you can skip linked databases. They are entirely optional.

Click Next to proceed to Step 2.

Step 2: Definitions

This is where you define the dynamic property schema for your skills. The Skill Forge uses a two-level property system:

Skill-Level Properties — apply to the skill as a whole (e.g., Skill Type, Element, Is Passive)
Rank-Level Properties — apply to each individual rank of a skill (e.g., Damage, Mana Cost, Area of Effect)

If you chose the ARPG template, you will see pre-populated definitions at both levels. You can customize them freely.

Property Types

There are 4 types of dynamic properties, available at both skill-level and rank-level:

Type	What It Stores	Example
Category	Selection from a list of named entries	Skill Type: [Attack, Buff, Debuff, Heal, Summon]
Flag	Boolean (true/false)	Is Passive, Is Ultimate, Requires Line of Sight
Numeric	Float or integer value (optionally a range)	Mana Cost, Cooldown, Cast Time, Base Damage
Text	String value (single or multi-line)	Tooltip, Lore Text, VFX Path

Adding a Property

To add a new property, expand the relevant section (e.g., Skill-Level Categories) and click the + button at the bottom of the list. Fill in the label/name and any additional settings (entries for categories, constraints for numerics, line count for texts).

Removing or Reordering

Use the - button to remove a property, or drag entries in the ReorderableList to reorder them. All existing skill entries are automatically synced when you add, remove, or reorder definitions.

JSON Schema Export

At the bottom of Step 2, you will find the JSON Schema section. This lets you export your property definitions in 3 formats (Full JSON, Light JSON, Markdown) for AI-assisted bulk content generation. You can also import skills from JSON. See AI Workflow for details.

Click Next to proceed to Step 3.

Step 3: Builder

The builder is a split-panel editor where you create and edit individual skill entries.

Left Panel — Skill List

The left panel shows all your skills in a scrollable list with:

Search bar — filter by name or code
Category filter — show only skills of a specific type
Sort — alphabetical, by code, or by category
Pagination — handles large lists efficiently
Bulk operations — select multiple skills for delete or duplicate
+ / - buttons — add or remove skills

Click any skill in the list to select it and edit its details in the right panel.

Right Panel — Skill Editor

The right panel displays all editable fields for the selected skill, organized into foldout sections:

Identity — Code (SCREAMING_SNAKE_CASE), display name, description, icon
Categories — dropdown selectors for each skill-level category
Flags — toggle checkboxes for each skill-level flag
Numeric Properties — value fields for each skill-level numeric
Text Properties — text fields for each skill-level text
Ranks — a list of ranks, each with its own rank-level properties, upgrade costs (resource code + amount), and optional SAF modifier assets
Prerequisites — conditions that must be met to learn/use the skill (e.g., "FIREBALL at least rank 3")
Skill Modifiers — SAF modifier assets attached to the skill itself (requires Simple Attribute Forge)
Cross-Forge References — 12 fields linking to items, enemies, quests, and factions from companion forges

Creating Your First Skill

1 Click the + button in the left panel to add a new skill.

2 In the Identity section, set the Code to FIREBALL and the Display Name to Fireball. Add a description like Hurls a ball of fire at the target.

3 Set category values (e.g., Skill Type: Attack, Element: Fire).

4 Set flag values (e.g., Is Passive: unchecked).

5 Set numeric values (e.g., Mana Cost: 25, Cooldown: 3.0).

6 Expand the Ranks section and add ranks. Each rank has its own rank-level property values (e.g., Rank 1: Damage 50, Rank 2: Damage 80, Rank 3: Damage 120).

Repeat to add more skills. Use Duplicate to clone an existing skill as a starting point.

Click Next to proceed to Step 4.

Step 4: Settings

Configure where and how the database is generated.

Output Path

Set the folder where generated files will be placed. The default is Assets/GeneratedSkillDatabases/. Click Browse to choose a different location.

Custom Paths

Enable Use Custom Paths to specify separate output folders for scripts (.cs files) and assets (.asset files). Useful if you want scripts in a Scripts/ folder and assets in a Data/ folder.

Generation Toggles

Generate Enum — produces the {Prefix}Type.cs enum file. Disable if you want to manage skill identifiers differently.
Generate Database — produces the {Prefix}Database.cs ScriptableObject and {Prefix}DatabaseEditor.cs custom inspector. Almost always left enabled.

File Preview

The bottom of Step 4 shows a preview of all files that will be generated, including their full paths. Review this before proceeding.

Click Next to proceed to Step 5.

Step 5: Generate

The final step shows a summary of your database and a Generate button.

Summary

Review the summary to confirm everything is correct: database name, number of skills, number of properties, output paths, and enabled generation options.

Generation Process

Click Generate to start the two-phase generation:

1 Phase 1 — Script Generation: The forge writes the .cs files (enum, database class, custom editor) to your output folder. Unity then triggers a domain reload to compile the new scripts.

2 Phase 2 — Asset Creation: After the domain reload completes, the forge automatically creates the .asset ScriptableObject and populates it with all your skill data. A log message confirms completion.

Do not close the wizard window or switch editor focus during generation. The two-phase process relies on an [InitializeOnLoad] handler that runs after the domain reload to complete Phase 2.

Generated Files

After generation completes, you will find these files in your output folder:

Assets/GeneratedSkillDatabases/ RPGSkillsType.cs ← enum: RPGSkillsType.FIREBALL, .ICE_BOLT, etc. RPGSkillsDatabase.cs ← ScriptableObject implementing ISimpleSkillDataSource RPGSkillsDatabaseEditor.cs ← custom inspector with search, sort, filter RPGSkillsDatabase.asset ← your data, ready to assign

Done! Select the .asset file in the Project window and inspect it. The custom editor displays your skills in the same split-panel layout as the wizard's builder.

Using Your Database at Runtime

The generated database implements ISimpleSkillDataSource, giving you a clean API to query skill data from any script.

Assigning the Database

Add a ScriptableObject field to your MonoBehaviour and drag the generated .asset file onto it in the Inspector:

using SimpleSkillForge;
using UnityEngine;

public class SkillManager : MonoBehaviour
{
    [SerializeField] private ScriptableObject skillDatabase;

    private ISimpleSkillDataSource _skills;

    void Awake()
    {
        _skills = skillDatabase as ISimpleSkillDataSource;
    }
}

Querying Skills

Use the interface methods to access your data:

// Get all skill definitions
SimpleSkillDefinition[] allSkills = _skills.GetSkillDefinitions();

// Look up a skill by code
SimpleSkillDefinition? fireball = _skills.GetSkillByCode("FIREBALL");

// Get all skill codes and names
string[] codes = _skills.GetSkillCodes();
string[] names = _skills.GetSkillNames();

// Check if a skill exists
bool exists = _skills.HasSkill("FIREBALL");

// Get the generated enum type for type-safe lookups
Type enumType = _skills.GetSkillEnumType();

Reading Dynamic Properties

Access the dynamic properties you defined in Step 2 using index-based accessors. The index corresponds to the order you defined them (0-based):

SimpleSkillDefinition skill = allSkills[0];

// Skill-level properties
int skillType = skill.GetCategoryValue(0);      // first category (e.g., Skill Type)
bool isPassive = skill.GetFlagValue(0);          // first flag (e.g., Is Passive)
float manaCost = skill.GetNumericValue(0);       // first numeric (e.g., Mana Cost)
string tooltip = skill.GetTextValue(0);          // first text (e.g., Tooltip)

// Rank-level properties (on each rank)
SimpleSkillRank rank = skill.ranks[0];
float damage = rank.GetNumericValue(0);          // first rank-level numeric (e.g., Damage)

Property Definition Labels

To get human-readable labels for your properties (useful for UI), query the data source:

// Skill-level property labels
string[] categoryLabels = _skills.GetCategoryLabels();   // ["Skill Type", "Element", ...]
string[] flagNames = _skills.GetFlagNames();              // ["Is Passive", "Is Ultimate", ...]
string[] numericNames = _skills.GetNumericNames();        // ["Mana Cost", "Cooldown", ...]
string[] textNames = _skills.GetTextNames();              // ["Tooltip", "Lore", ...]

// Category entries (options for a specific category)
string[] skillTypes = _skills.GetCategoryEntries(0);     // ["Attack", "Buff", "Debuff", ...]

// Rank-level property labels
string[] rankCatLabels = _skills.GetRankCategoryLabels();
string[] rankFlagNames = _skills.GetRankFlagNames();
string[] rankNumericNames = _skills.GetRankNumericNames();
string[] rankTextNames = _skills.GetRankTextNames();

Filtering

Query skills by property values:

// All skills where category 0 (Skill Type) == entry 3 (Heal)
SimpleSkillDefinition[] heals = _skills.GetSkillsByCategory(0, 3);

// All skills where flag 0 (Is Passive) == true
SimpleSkillDefinition[] passives = _skills.GetSkillsByFlag(0, true);

// All skills where numeric 1 (Cooldown) is between 0 and 5
SimpleSkillDefinition[] quickSkills = _skills.GetSkillsByNumericRange(1, 0f, 5f);

// All skills usable by a specific character class (requires SAF Character Templates)
SimpleSkillDefinition[] mageSkills = _skills.GetSkillsUsableByClass("Mage");

Using SimpleSkillHelper

The static helper class provides utility functions without needing a tracker instance:

// Check if a skill's prerequisites are met
// The valueProvider function returns the player's current value for each prerequisite code
bool canLearn = SimpleSkillHelper.CheckAllPrerequisites(
    fireball.Value,
    (code) => GetPlayerSkillRank(code)  // your function that returns current rank
);

// Find all skills granted by a specific item
SimpleSkillDefinition[] bookSkills = SimpleSkillHelper.FindSkillsGrantedByItem(
    _skills, "TOME_OF_FIRE"
);

// Check if the player can afford the upgrade to the next rank
bool canAfford = SimpleSkillHelper.CanAffordRankUp(
    fireball.Value, currentRank,
    (resourceCode) => GetPlayerResource(resourceCode)  // your resource lookup
);

Next Steps

You have created your first skill database. Here is where to go from here:

Skill Forge Deep Dive

Learn about all features: rank progression, prerequisites, cross-forge references, and the two-level property system in detail.

Skill Forge Documentation →

Build Skill Trees

Create talent trees with grid-based node layouts that reference your skills. Nodes have point costs, level requirements, and parent-child connections.

Skill Tree Forge →

Create Skill Sets

Design loadout templates with typed slots and threshold-based set bonuses. "Equip 3 fire skills for +20% fire damage."

Skill Set Forge →

Define Combos

Build skill sequences with timing windows and threshold rewards. "Fireball, Ice Bolt, Lightning within 2 seconds = Elemental Burst."

Skill Combo Forge →

AI-Assisted Content

Export your schema to JSON or Markdown, feed it to an AI assistant, and import hundreds of generated skills back into your database.

AI Workflow →

Cross-Forge Integration

Connect to Simple Attribute Forge, Simple Item Forge, Simple Enemy Forge, and Simple Quest Forge for deep cross-system references.

Integration →