Build Your Skill System

Stop hand-coding skill databases and writing boilerplate ScriptableObject editors. Simple Skill Forge gives you 4 interconnected wizard tools that generate production-ready databases with custom editors, type-safe enums, runtime trackers, and AI-assisted content generation — all from a guided, step-by-step interface inside the Unity Editor.

Whether you are building an ARPG with hundreds of hand-crafted abilities, a MOBA with precise skill loadouts, or a soulslike with deep talent trees, Simple Skill Forge handles the infrastructure so you can focus on game design.

Why Simple Skill Forge?

The Four Forges

Utility Windows

What Gets Generated

Each forge generates 4 files per database:

Runtime Components

Plus SimpleSkillComboEvaluator — a static utility for evaluating combo progress, getting next valid skills, and checking timing windows without instantiating a tracker.

Getting Started

See Quick Start for a complete walkthrough.

Interconnected Ecosystem

Simple Skill Forge is part of the Simple Forge Ecosystem — a family of Unity tools that work independently but become more powerful together:

All integrations use safe reflection — no hard dependencies, no compile errors if companion packages are not installed. Install them when you need them.

See Integration for details on each cross-forge connection.

Package Manager (UPM)

The recommended way to install Simple Skill Forge is through Unity's Package Manager using a Git URL. This approach makes updates easy and keeps the package outside your Assets folder.

Option A — Git URL

Option B — manifest.json

You can also add the package directly to your project's Packages/manifest.json file:

Save the file and return to Unity. The package will be resolved automatically.

Asset Store

Simple Skill Forge is available on the Unity Asset Store.

The package will be placed under Assets/SimpleSkillForge/.

Manual Import

If you received Simple Skill Forge as a .unitypackage file:

Verifying Installation

After installation, verify that everything is working correctly:

If you encounter issues, see Troubleshooting.

Optional Companions

Simple Skill Forge works standalone with zero dependencies. However, it integrates with 4 companion packages from the Simple Forge Ecosystem. When a companion is detected, SSF automatically enables additional features via safe reflection — no configuration required.

Installing Companions

Install companion packages the same way you installed SSF (UPM, Asset Store, or manual import). Once imported, SSF detects them automatically on the next domain reload. No restart or manual configuration is needed.

Detection Mechanism

SSF uses two detection methods that work together:

• UPM detection: The .asmdef files contain versionDefines entries that set scripting defines (e.g., SIMPLE_ATTRIBUTE_FORGE, SIMPLE_ITEM_FORGE) when companion packages are present in the Package Manager.
• Reflection detection: Bridge classes (SAFBridge, SIFBridge, SEFBridge, SQFBridge) probe for companion types at runtime using Type.GetType(). This handles non-UPM installations (Asset Store, manual import).

Assembly Definitions

Simple Skill Forge uses two assembly definitions to keep runtime and editor code properly separated:

Referencing SSF in Your Code

If your project uses assembly definitions, add a reference to SimpleSkillForge.Runtime in your runtime .asmdef to access SSF types:

For editor scripts that need SSF editor types, reference both assemblies:

Version Defines

The runtime assembly's .asmdef includes versionDefines for all companion packages. When a companion is installed via UPM, Unity automatically sets the corresponding scripting define symbol:

These defines gate #if blocks in SSF source code so that companion-specific features compile only when the companion is present.

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

Step 1: Setup

Open the Skill Forge wizard:

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:

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.

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:

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

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:

Generated Files

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

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:

Querying Skills

Use the interface methods to access your data:

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):

Property Definition Labels

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

Filtering

Query skills by property values:

Using SimpleSkillHelper

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

Next Steps

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

Overview

The Skill Forge is the primary forge in Simple Skill Forge. It generates complete skill databases as ScriptableObjects with type-safe enums, custom inspectors, and a runtime interface (ISimpleSkillDataSource) for querying skill data from game code.

What makes the Skill Forge unique among the four forges is its two-level dynamic property system. You define properties at two independent levels:

• Skill-Level Properties (Level 1) — apply to the skill as a whole. Examples: Skill Type, Element, Is Passive, Mana Cost, Tooltip.
• Rank-Level Properties (Level 2) — apply to each individual rank within a skill. Examples: Damage, Healing Amount, Area of Effect, Duration.

On top of the two-level property system, each skill supports:

• Multi-rank progression with per-rank upgrade costs and SAF modifier assets
• Prerequisites for skill unlock conditions
• 12 cross-forge reference fields linking skills to items (SIF), enemies (SEF), quests (SQF), and attributes/modifiers (SAF)
• Character class restrictions via SAF Character Templates

Open the Skill Forge wizard from the Unity menu:

The 5-Step Wizard

The Skill Forge follows the standard 5-step wizard pattern shared across all Living Failure forges.

Step 1: Setup

Configure the foundational settings for your skill database:

Step 2: Definitions

Define the dynamic property schema for your skills. This is where the two-level system comes into play. You define properties separately for:

• Skill-Level — Categories, Flags, Numerics, and Texts that apply to the skill as a whole
• Rank-Level — Categories, Flags, Numerics, and Texts that apply to each individual rank

Each property type is managed via a ReorderableList. Add, remove, reorder, and configure properties with full control. All existing skill entries are automatically synced when definitions change.

Step 2 also includes a JSON Schema section for AI-assisted content generation. Export your schema in 3 formats (Full JSON, Light JSON, Markdown) and import skills from JSON. See AI Workflow for details.

Step 3: Builder

The builder is a split-panel editor for creating and editing individual skills.

Left Panel — a scrollable list of all skills with:

• Search bar (filter by name or code)
• Category filter dropdown
• Sort options (alphabetical, by code, by category)
• Pagination for large lists
• Bulk select, delete, and duplicate
• Category type indicator badge ([TypeName])
• + / - buttons for adding and removing skills

Right Panel — detail editor for the selected skill, organized into foldout sections:

• Identity — code (SCREAMING_SNAKE_CASE), display name, description, icon (Sprite)
• 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 — nested rank entries, each with rank-level properties, upgrade costs, and modifier assets
• Prerequisites — unlock conditions (targetCode + comparison + value)
• Skill Modifiers — SAF modifier assets on the skill itself
• Cross-Forge References — 12 fields organized by companion forge
• Character Class Restrictions — allowed character classes

Step 4: Settings

Configure output paths and generation toggles:

• Output Path — folder for generated files (default: Assets/GeneratedSkillDatabases/)
• Use Custom Paths — separate folders for scripts and assets
• Generate Enum — toggle {Prefix}Type.cs generation
• Generate Database — toggle database and editor generation
• File Preview — shows all files that will be created

Step 5: Generate

Review the summary and click Generate to produce your database. The generation uses a two-phase process:

Property Types

Both skill-level and rank-level support 4 types of dynamic properties:

Categories

A selection from a named list of entries. Each category has a label and a list of string entries.

Flags

Boolean properties. Each flag has a name and a default value.

Numerics

Float or integer values with optional min/max constraints.

Texts

String values. Each text property has a name and a line count (1 = single line, >1 = multi-line TextArea).

Filtering by Properties

The database interface provides filtering methods for all property types:

Ranks and Upgrade Costs

Each skill can have multiple ranks representing progression levels. Ranks are stored as SimpleSkillRank[] on the skill definition. Each rank has:

Upgrade Costs

Each rank can have multiple upgrade costs. An upgrade cost pairs a resource code with an amount:

The resourceCode is a free-form string. It can reference an item code from SIF, an attribute code from SAF, or any custom identifier your game uses. The forge does not validate the code — your game logic interprets it.

Querying Ranks

Reagent Costs vs. Upgrade Costs

Prerequisites

Skills can have prerequisites — conditions that must be met before the skill can be learned or used. Each prerequisite is a SimpleSkillPrerequisite:

Prerequisites are evaluated using a Func<string, float> value provider — a function you supply that returns the current value for any target code. This keeps the system completely game-agnostic:

Common prerequisite patterns:

• FIREBALL GreaterOrEqual 3 — "Fireball must be at least rank 3"
• PLAYER_LEVEL GreaterOrEqual 10 — "Character level 10 required"
• ICE_BOLT Equals 0 — "Must not have learned Ice Bolt" (mutual exclusion)

Cross-Forge References

Each skill has 12 cross-forge reference fields that link skills to data from companion forges. All references are stored as string codes (no hard dependencies). The companion forge does not need to be installed for the data to be stored — it is just strings.

SIF (Simple Item Forge) — 4 Fields

SEF (Simple Enemy Forge) — 5 Fields

SQF (Simple Quest Forge) — 2 Fields

SAF (Simple Attribute Forge) — 1 Field

Additionally, each rank has its own modifiers[] array for effects gained at specific ranks.

Convenience Accessors

The SimpleSkillDefinition struct provides boolean convenience properties for checking whether cross-forge references are set:

Cross-Forge Queries

The ISimpleSkillDataSource interface provides reverse-lookup queries for all cross-forge fields:

Character Class Restrictions

Skills can be restricted to specific character classes using the allowedCharacterClasses field. This integrates with SAF Character Templates — if you have character template assets linked in Step 1, the wizard displays a checkbox list of available class names in Step 3. You can also add class names manually.

An empty allowedCharacterClasses array means the skill is usable by all classes.

Overview

The Skill Tree Forge generates skill tree databases — grid-based talent trees where nodes reference skills from Skill Forge databases and are connected by directed parent-child edges. Each tree supports branch groups for specialization paths, point costs, level requirements, and single-level dynamic properties.

Generated databases implement ISimpleSkillTreeDataSource and produce the same 4-file output as the Skill Forge (enum, database, editor, asset), with the suffix Tree (e.g., ARPGTreeType.cs, ARPGTreeDatabase.cs).

Open the Skill Tree Forge wizard from the Unity menu:

Key features:

• Grid-based node layout with row/column positioning
• Parent-child connections enforcing unlock order
• Branch groups for specialization paths (e.g., "Fire", "Ice", "Lightning")
• Per-node point cost, required level, and required points in tree
• Nodes reference skill codes from any linked Skill Forge database
• Single-level dynamic properties on each tree
• Runtime tracker with unlock/reset/snapshot support
• Character class restrictions via SAF Character Templates

The 5-Step Wizard

The Skill Tree Forge follows the same 5-step wizard pattern as all forges.

Step 1: Setup

Configure the database name, namespace, class prefix, and template. The Skill Tree Forge adds a Linked Skill Databases section where you drag-and-drop Skill Forge database assets. Linking a skill database enables searchable dropdown menus for node skillCode fields in Step 3. You can link multiple skill databases.

You can also link SAF Character Template assets for class restriction support.

Step 2: Definitions

Define single-level dynamic properties for your trees. Unlike the Skill Forge, there is no rank-level — properties apply to the tree definition itself (e.g., "Tree Type", "Total Point Cap", "Is Starter Tree"). The JSON schema export/import section is available for AI-assisted content generation.

Step 3: Builder

Split-panel editor (280px left panel). The left panel lists all tree definitions with search, filter, sort, bulk operations, and pagination. The right panel shows foldout sections for:

• Identity — code, display name, description, icon
• Categories / Flags / Numerics / Texts — single-level properties
• Nodes — ReorderableList of tree nodes (9 editable fields per node)
• Connections — ReorderableList of directed edges (from/to node dropdowns)
• Character Class Restrictions — allowed character classes

Step 4: Settings

Output paths, custom paths toggle, generation toggles, and file preview.

Step 5: Generate

Two-phase generation producing {Prefix}TreeType.cs, {Prefix}TreeDatabase.cs, {Prefix}TreeDatabaseEditor.cs, and the .asset file.

Nodes

Each tree contains an array of SimpleSkillTreeNode structs. A node represents a single unlockable entry in the tree, referencing a skill from a linked Skill Forge database.

Querying Nodes

Connections

Connections are directed edges (SimpleSkillTreeConnection) that define parent-child unlock dependencies between nodes. A child node cannot be unlocked until all parent nodes are unlocked.

Querying Connections

Single-Level Properties

Skill trees use single-level dynamic properties (Categories, Flags, Numerics, Texts) on the tree definition itself. There is no child-level like the Skill Forge's rank-level properties.

Runtime: SimpleSkillTreeTracker

SimpleSkillTreeTracker is a runtime state tracker that manages skill tree node unlocks, point spending, prerequisite validation, cascade resets, and serializable snapshots.

Setup

Unlocking Nodes

Queries

Reset

Events

Snapshots (Save/Load)

Overview

The Skill Set Forge generates skill set databases — loadout templates that group skills into typed slots with threshold-based set bonuses that activate when enough skills from the set are equipped. Think item set bonuses from Diablo or gear sets from MMOs, but applied to skills.

Generated databases implement ISimpleSkillSetDataSource and produce the standard 4-file output with the suffix Set (e.g., ARPGSetType.cs, ARPGSetDatabase.cs).

Open the Skill Set Forge wizard from the Unity menu:

Key features:

• Typed slots with required/optional designation
• Skill code references from linked Skill Forge databases
• Threshold-based set bonuses (e.g., "Equip 3/5 for bonus")
• SAF modifier assets on bonuses
• Single-level dynamic properties on each set
• Runtime manager with equip/unequip, bonus tracking, and snapshots
• Character class restrictions via SAF Character Templates

The 5-Step Wizard

The Skill Set Forge follows the same 5-step wizard pattern as all forges.

Step 1: Setup

Configure the database name, namespace, class prefix, and template. Link Skill Forge database assets for searchable skill code dropdowns in Step 3. Link SAF Character Template assets for class restriction support. Supports multiple linked databases with duplicate detection.

Step 2: Definitions

Define single-level dynamic properties for your sets (e.g., "Set Type", "Max Slots", "Is Starter Set"). JSON schema export/import is available for AI-assisted content generation with context-aware usage hints.

Step 3: Builder

Split-panel editor (280px left panel). The right panel shows foldout sections for:

• Identity — code, display name, description, icon
• Categories / Flags / Numerics / Texts — single-level properties
• Slots — ReorderableList with 3 fields per slot (slotType, skillCode, isRequired)
• Bonuses — ReorderableList with threshold count, description, and SAF modifier assets
• Character Class Restrictions — allowed character classes

Step 4: Settings

Output paths, custom paths toggle, generation toggles, and file preview.

Step 5: Generate

Two-phase generation producing {Prefix}SetType.cs, {Prefix}SetDatabase.cs, {Prefix}SetDatabaseEditor.cs, and the .asset file with all slot, bonus, and modifier data baked in.

Slots

Each set contains an array of SimpleSkillSetSlot structs. A slot defines a position in the loadout with a type label, an assigned skill code, and a required flag.

Querying Slots

Bonuses

Each set can have multiple SimpleSkillSetBonus entries that activate when enough skills from the set are equipped. This follows the same threshold pattern as item set bonuses.

Querying Bonuses

Example: Tiered Bonuses

A set with 5 slots might define bonuses like this:

With 3 skills equipped, both the "2-piece" and "3-piece" bonuses are active. GetActiveBonuses(3) returns both.

Single-Level Properties

Skill sets use single-level dynamic properties on the set definition itself.

Runtime: SimpleSkillBarManager

SimpleSkillBarManager is a runtime manager that handles equipping/unequipping skills to set slots, tracks threshold-based set bonuses, fires events on changes, and supports serializable snapshots for save/load.

Setup

Equip and Unequip

Queries

Events

Snapshots (Save/Load)

Overview

The Skill Combo Forge generates skill combo databases — sequential skill chains where players execute skills in a specific order to earn threshold-based rewards. Each combo defines ordered steps with timing windows, alternate skill choices, and branch groups, plus rewards that trigger at step count thresholds.

Generated databases implement ISimpleSkillComboDataSource and produce the standard 4-file output with the suffix Combo (e.g., ARPGComboType.cs, ARPGComboDatabase.cs).

Open the Skill Combo Forge wizard from the Unity menu:

Key features:

• Ordered steps with sortOrder sequencing
• Required and optional steps
• Alternate skill choices per step (alternateSkillCodes[])
• Branch groups for OR-alternative step paths
• Per-step timing windows (maxDelay in seconds)
• Threshold-based rewards with SAF modifier assets
• Single-level dynamic properties on each combo
• Runtime tracker for automatic combo detection and progression
• Static evaluator for stateless combo analysis
• Character class restrictions via SAF Character Templates

The 5-Step Wizard

The Skill Combo Forge follows the same 5-step wizard pattern as all forges.

Step 1: Setup

Configure the database name, namespace, class prefix, and template. Link Skill Forge database assets for searchable skill code dropdowns in Step 3. Link SAF Character Template assets for class restriction support.

Step 2: Definitions

Define single-level dynamic properties for your combos (e.g., "Combo Type", "Element", "Damage Multiplier", "Is Finisher"). JSON schema export/import with context-aware usage hints and 5 combo design patterns (Chain Combo, Rotation, Reaction Chain, Hit String, Synergy Set).

Step 3: Builder

Split-panel editor (280px left panel). The right panel shows foldout sections for:

• Identity — code, display name, description, icon
• Categories / Flags / Numerics / Texts — single-level properties
• Steps — ReorderableList with 6 fields per step (skillCode, isRequired, alternateSkillCodes mini-list, branchGroup, maxDelay, sortOrder)
• Rewards — ReorderableList with threshold count, description, effect code, and SAF modifier assets
• Character Class Restrictions — allowed character classes

Step 4: Settings

Output paths, custom paths toggle, generation toggles, and file preview.

Step 5: Generate

Two-phase generation producing {Prefix}ComboType.cs, {Prefix}ComboDatabase.cs, {Prefix}ComboDatabaseEditor.cs, and the .asset file with all step, reward, and modifier data baked in.

Steps

Each combo contains an array of SimpleSkillComboStep structs, sorted by sortOrder at runtime. A step defines a single position in the combo sequence.

Querying Steps

Example: Elemental Burst Combo

The player must cast Fireball, then Ice Bolt (or Frost Nova) within 2 seconds, then Lightning Strike within 2 more seconds. The optional Arcane Blast at the end earns a bonus reward if hit within 3 seconds but is not required for combo completion.

Rewards

Each combo can have multiple SimpleSkillComboReward entries that trigger when enough steps are completed. This follows the same threshold pattern as set bonuses.

Querying Rewards

Example: Tiered Rewards

Each tier stacks — completing 3 steps earns both the 2-step and 3-step rewards.

Single-Level Properties

Skill combos use single-level dynamic properties on the combo definition itself.

Runtime: SimpleSkillComboTracker

SimpleSkillComboTracker tracks active skill combos at runtime. Feed skill usage into the tracker and it automatically evaluates all defined combos simultaneously — starting new combos when a matching first step is detected, progressing active combos on subsequent matches, dropping combos when timing windows expire, and triggering rewards at thresholds.

Setup

Feeding Skill Usage

Each call to OnSkillUsed does the following:

• Checks timing windows on all active combos (drops expired ones)
• Advances active combos if the skill matches their next step
• Skips optional steps when the skill matches a later required step
• Triggers rewards when step thresholds are reached
• Completes combos when all steps are matched
• Starts new combos if the skill matches any inactive combo's first step

Queries

Events

Snapshots (Save/Load)

Runtime: SimpleSkillComboEvaluator

SimpleSkillComboEvaluator is a static utility class for evaluating combos without instantiating a tracker. All methods are stateless pure functions — useful for UI previews, combo planning, AI decision-making, and tooltip generation.

Evaluating a Combo

Getting Next Valid Skills

This is especially useful for UI hints ("Cast one of these skills to continue the combo") and AI skill selection.

Finding Matching Combos

Quick Checks

Tracker vs. Evaluator

AI-Assisted Content Generation

All 4 forges support schema export in Step 2 (Definitions). Export your property schema with embedded AI instructions, hand it to ChatGPT, Claude, or any LLM, and import the generated content back into your database — all without writing code.

This workflow lets you:

• Generate hundreds of skills/trees/sets/combos from a single prompt
• Maintain consistency with your property schema (AI can only use your defined properties)
• Iterate rapidly on content design before committing to implementation
• Use AI as a creative partner for brainstorming skill concepts

Export Formats

Each forge offers 3 export formats:

Export Workflow

Embedded AI Instructions

The exported file includes a BuildInstructions section (600+ lines for the Skill Forge) that teaches the AI everything it needs to know:

• Property system explanation — how Categories, Flags, Numerics, and Texts work at both skill-level and rank-level
• Ecosystem description — all 7 forge systems and how they connect
• User questions — 7-step questionnaire for the AI to ask the user about their game
• Per-property guidance — context-aware usage hints for each defined property
• Skill archetype patterns — 8 common skill types with design guidance
• Rank progression patterns — how to design meaningful rank upgrades
• Format examples — exact JSON structure using your actual definitions
• 5-phase workflow — structured process for the AI to follow
• Cross-forge awareness — what data is available from companion packages

Import Workflow

The import validates each entry: codes must be unique C# identifiers, property arrays must match your defined schema length, and required fields (code, displayName) must be present.

Tips for AI Generation

Be Specific About Your Game

Tell the AI what kind of game you're making. "Generate ARPG skills" produces generic results. "Generate skills for a dark fantasy ARPG where the player is a fallen angel regaining divine powers" produces much more interesting content.

Use the Full JSON Format

The Full JSON export includes your existing entries as examples. This gives the AI concrete patterns to follow, resulting in more consistent output.

Generate in Batches

Ask for 10–20 entries at a time rather than 100+. Smaller batches give the AI more room to be creative and reduce the chance of repetitive content.

Iterate on Definitions First

Before generating content, make sure your property definitions are finalized. Changing definitions after importing 200 skills means all those skills need to be re-synced.

Review and Edit

AI-generated content is a starting point. Use the builder in Step 3 to review, edit, and refine each entry. The split-panel editor with search, sort, and filter makes this efficient.

Genre Templates

All 4 forges ship with 6 genre templates that pre-populate property definitions with genre-appropriate Categories, Flags, Numerics, and Texts. Templates are a starting point — you can modify, add, or remove any property after applying a template.

Select a template in Step 1 (Setup) of any wizard. Choosing "None" starts with a blank slate. Changing templates after defining entries will prompt for confirmation, since it replaces all property definitions.

ARPG Template

Designed for action RPGs (Diablo, Path of Exile, Last Epoch). Emphasizes damage types, resource management, and scaling per rank.

Skill-Level Properties (Skill Forge)

Rank-Level Properties (Skill Forge)

MOBA Template

Designed for MOBAs (League of Legends, Dota 2). Focuses on ability scaling, lane impact, and team synergy.

Skill-level categories include Lane Phase (Early, Mid, Late), Role Fit (Carry, Support, Tank, Assassin, Mage, Bruiser), and Crowd Control type. Rank-level numerics emphasize per-level scaling values and cooldown reduction.

MMO Template

Designed for MMOs (World of Warcraft, Final Fantasy XIV). Emphasizes class identity, raid roles, and resource management.

Skill-level categories include Skill Category (Core, Talent, Racial, Profession), Resource Type (Mana, Energy, Rage, Focus, Combo Points), and Cast Type (Instant, Channeled, Cast Time, Toggle). Rank-level properties track per-rank GCD modifications and resource cost scaling.

Turn-Based Template

Designed for turn-based RPGs (Final Fantasy, Persona, Fire Emblem). Focuses on action economy, turn order, and elemental weakness systems.

Skill-level categories include Action Cost (Free, Half Turn, Full Turn, Multi-Turn), Element, and Range. Flags include "Consumes Turn" and "Can Counter". Rank numerics track hit rate, critical rate, and accuracy bonuses.

Action Template

Designed for action games (Devil May Cry, Bayonetta, God of War). Emphasizes combo potential, input complexity, and style scoring.

Skill-level categories include Input Type (Press, Hold, Charge, Direction+Press), Attack Type (Light, Heavy, Launcher, Slam, Projectile), and Cancel Window. Flags include "Can Air Cancel" and "Has Super Armor". Rank numerics include "Hit Count" and "Style Points".

Roguelike Template

Designed for roguelikes (Hades, Slay the Spire, Dead Cells). Emphasizes run synergies, randomized upgrades, and resource efficiency.

Skill-level categories include Rarity (Common, Uncommon, Rare, Epic, Legendary), Synergy Tag (multiple synergy groups), and Acquisition (Starter, Shop, Drop, Boss Reward, Secret). Flags include "Stackable" and "Removable". Rank numerics track "Stack Multiplier" and "Trigger Chance".

Customizing Templates

After applying a template, you can freely:

• Add new categories, flags, numerics, or texts
• Remove any property you don't need
• Rename labels and entries
• Reorder properties (drag handles in the ReorderableList)
• Add category entries to existing categories

All changes in Step 2 automatically sync to existing entries in Step 3. New properties get default values; removed properties are cleaned up.

Data Structures

All runtime data structures live in the SimpleSkillForge namespace and are [Serializable] structs. The Skill Forge uses a two-level property system (skill-level + rank-level), while the Tree, Set, and Combo forges use single-level properties.

SimpleSkillDefinition

The main skill entry. Contains identity, two-level dynamic properties, nested ranks, prerequisites, modifier references, and 12 cross-forge reference fields.

Identity Fields

Skill-Level Dynamic Properties (Level 1)

Nested Data

Cross-Forge References: SIF (Item Forge)

Cross-Forge References: SEF (Enemy Forge)

Cross-Forge References: SQF (Quest Forge)

Cross-Forge References: SAF Character Templates

Accessor Methods

Convenience Properties

Query Methods

SimpleSkillRank

A single rank of a skill. Each rank has its own rank-level dynamic properties (Level 2), upgrade costs, and optional SAF modifier references.

Accessor Methods

SimpleSkillUpgradeCost

A resource cost for upgrading a skill to a specific rank. The resourceCode can reference an item code (SIF), attribute code (SAF), or any custom string.

SimpleSkillReagentCost

An item consumed each time the skill is used. Different from SimpleSkillUpgradeCost which is for leveling/ranking up.

SimpleSkillPrerequisite

A prerequisite condition for unlocking a skill. Evaluated as: valueProvider(targetCode) [comparison] value

SimpleSkillComparison (enum)

Comparison operators for prerequisite evaluation.

SimpleSkillTreeDefinition

A complete skill tree with identity, nodes, connections, and single-level dynamic properties.

Fields

Accessor Methods

Convenience Properties

SimpleSkillTreeNode

A single node in a skill tree. References a skill code and defines grid position, unlock requirements, and branch membership.

SimpleSkillTreeConnection

A directed edge in a skill tree: parent to child unlock dependency. The child node cannot be unlocked until the parent is unlocked.

SimpleSkillSetDefinition

A complete skill set with identity, slots, threshold-based bonuses, and single-level dynamic properties.

Fields

Accessor Methods

Convenience Properties

SimpleSkillSetSlot

A single slot in a skill set, with a type label, skill reference, and required flag.

SimpleSkillSetBonus

A threshold-based bonus that activates when enough skills from the set are equipped.

SimpleSkillComboDefinition

A complete skill combo with identity, ordered steps, threshold-based rewards, and single-level dynamic properties.

Fields

Accessor Methods

Convenience Properties

SimpleSkillComboStep

A single step in a combo chain, with a primary skill, alternates, branch grouping, and timing.

SimpleSkillComboReward

A threshold-based reward that activates when enough combo steps are completed.

Interfaces

Each forge generates a ScriptableObject database class that implements one of these interfaces. Cast your generated database asset to the interface for type-safe access.

ISimpleSkillDataSource

Interface for generated skill databases. Supports two-level dynamic properties (skill-level + rank-level).

Skill Access

Rank Access

Skill-Level Property Definitions (Level 1)

Rank-Level Property Definitions (Level 2)

Dynamic Filtering

Cross-Reference Queries

Cross-Forge Queries: SIF

Cross-Forge Queries: SEF

Cross-Forge Queries: SQF

Cross-Forge Queries: SAF Character Templates

ISimpleSkillTreeDataSource

Interface for generated skill tree databases. Supports single-level dynamic properties on trees.

Tree Access

Node and Connection Access

Property Definitions (Single-Level)

Dynamic Filtering

Cross-Reference and Class Queries

ISimpleSkillSetDataSource

Interface for generated skill set databases. Supports single-level dynamic properties on sets.

Set Access

Slot and Bonus Access

Property Definitions (Single-Level)

Dynamic Filtering

Cross-Reference and Class Queries

ISimpleSkillComboDataSource

Interface for generated skill combo databases. Supports single-level dynamic properties on combos.

Combo Access

Step and Reward Access

Cross-Reference and Class Queries

Property Definitions (Single-Level)

Dynamic Filtering

Static Helpers

Stateless utility classes with pure functions. No instantiation needed — call methods directly on the static class.

SimpleSkillHelper

Static utility class for prerequisite evaluation, upgrade cost queries, cross-reference lookups, and rank-up affordability checks. All methods are pure functions.

Prerequisite Evaluation

Upgrade Cost Queries

Cross-Reference Queries

Cross-Forge Queries: SIF (Item Forge)

Cross-Forge Queries: SEF (Enemy Forge)

Cross-Forge Queries: SQF (Quest Forge)

Cross-Forge Queries: SAF Character Templates

Tree Node Lookup

Usage Example

SimpleSkillComboEvaluator

Static utility class for evaluating combo progress, finding matching combos, and computing next valid skills. Stateless — all methods are pure functions. Use this when you need combo evaluation without instantiating a tracker.

Methods

Result Types

ComboEvalResult

ComboMatch

Usage Example

State Trackers

Mutable runtime state managers. Instantiate them with a database reference, use methods to modify state, subscribe to events for reactive updates, and create/restore snapshots for save/load.

SimpleSkillTreeTracker

Tracks skill tree progression at runtime. Manages node unlocks, point spending, prerequisite validation, cascade resets, and serializable snapshots.

Constructor

Events

Properties

Lifecycle Methods

Node Unlock Methods

Query Methods

Reset Methods

Serialization

Usage Example

SimpleSkillBarManager

Manages skill set loadouts at runtime. Handles equipping/unequipping skills to set slots, tracks active set bonuses based on equipped count thresholds, and supports snapshot serialization.

Constructor

Events

Properties

Lifecycle Methods

Equip / Unequip Methods

Query Methods

Serialization

Usage Example

SimpleSkillComboTracker

Tracks active skill combos at runtime. Feed skill usage to auto-evaluate all defined combos simultaneously, handles timing windows, triggers threshold rewards, and supports snapshot serialization.

Constructor

Events

Properties

Skill Usage

Query Methods

Control Methods

Serialization

Usage Example

Supporting Types

These types are used internally by the static helpers and state trackers.

PrerequisiteResult

Returned by SimpleSkillHelper.EvaluatePrerequisites().

SimpleIntArray

Wrapper for int[] to allow serialization of nested arrays. Used for multi-select category values.

Snapshot Types

All snapshot types are [Serializable] classes compatible with JsonUtility.

Cross-Forge Integration

Simple Skill Forge integrates with 4 companion packages from the Living Failure ecosystem. All integrations use safe reflection — no hard dependencies, no compile errors, no #if preprocessor directives. Install companion packages when you need them; SSF adapts automatically.

How Bridges Work

SSF uses two detection paths:

1. UPM Detection (Automatic)

The .asmdef files contain versionDefines that detect companion packages by their UPM package name and set scripting defines automatically:

2. Reflection Detection (Fallback)

For non-UPM installs (Asset Store, .unitypackage), bridge classes use Type.GetType() to probe for companion types at editor time. Each bridge is a static class that caches type references and builds delegate-based accessors:

At runtime, the demo scenes use FindType() (scanning all loaded assemblies) instead of Type.GetType() with assembly-qualified names, since assembly names may vary between UPM and Asset Store installs.

Simple Attribute Forge (SAF)

When SAF is detected, the following features become available:

Modifier Assets

The Skill Forge builder (Step 3) shows a Skill Modifiers section where you can assign SimpleModifierAssetBase ScriptableObjects to skills. Each rank can also have its own modifier assets. The Skill Set Forge allows modifiers on set bonuses.

Character Class Restrictions

When SAF Character Templates are detected, all 4 forges show an Allowed Character Classes section. You can assign character template assets in Step 1, and the builder provides checkbox toggles for each detected class name plus a manual entry list.

At runtime, each definition struct has allowedCharacterClasses (string[]) with HasClassRestriction and IsUsableByClass() / IsAvailableToClass() accessors. The interfaces provide GetSkillsForClass() and GetSkillsUsableByClass() query methods.

Simple Item Forge (SIF)

When SIF is detected, the Skill Forge builder shows 4 cross-forge reference fields plus reagent costs:

Runtime Queries

Simple Enemy Forge (SEF)

When SEF is detected, the Skill Forge builder shows 5 cross-forge reference fields:

Runtime Queries

Simple Quest Forge (SQF)

When SQF is detected, the Skill Forge builder shows 2 cross-forge reference fields:

Runtime Queries

Character Class System

All 4 forge types (Skill, Tree, Set, Combo) support allowedCharacterClasses on their definition structs. This feature is enabled when SAF Character Templates are detected, but can also be used manually by typing class names directly.

How It Works

• In Step 1, assign Character Template assets to populate available class names
• In Step 3 (builder), toggle classes on/off per entry or type custom names
• An empty allowedCharacterClasses array means the entry is unrestricted (usable by all classes)
• A non-empty array means the entry is restricted to listed classes only

Runtime API

Demo Scenes

Simple Skill Forge ships with two interactive demo scenes that showcase all 4 forges and their runtime components. Both demos are generated procedurally via editor menu commands — no manual scene setup required.

ARPG Demo

A 4-tab interactive skill system with Royal Orange theme (1920x1080).

Tab 1: Skills

Left panel: searchable skill list with rank badges. Right panel: skill detail with identity, properties, rank stats (per-rank costs, UNLOCKED/LOCKED status), prerequisites (MET/NOT MET), and cross-forge connections. RANK UP button deducts resources. EQUIP TO BAR adds the skill to the bottom bar.

Tab 2: Skill Trees

Left panel: tree list. Right panel: node list showing skill name, SP cost, level requirement, and UNLOCK/UNLOCKED/LOCKED status. Click a node to unlock it (deducts skill points). RESET TREE refunds all points.

Tab 3: Loadout

Left panel: set list with equipped count. Right panel: dropdown per slot for skill assignment, X button to unequip, and set bonus progress (3/5 threshold bonuses with OK/[ ] indicators).

Tab 4: Combos

Left panel: combo list with step count. Right panel: step sequence with skill names, required/optional flags, timing windows, alternate skills, reward thresholds. Live tracker shows combo progress bars and next valid skills.

Bottom Bar

6 skill slots with CAST buttons. Casting updates combo tracking, shows combo progress, set status, and cast log. Cyclic assignment — equipping when full wraps to slot 0.

Top Bar

Class dropdown (filters all tabs by character class). Cheat buttons: +LVL, +SP, +Souls for testing.

Soulslike Demo

A 7-tab cross-forge showcase with upsell panel. Same Royal Orange theme.

Upsell Panel

Shown when any companion package (SAF/SIF/SEF/SQF) is not installed. Displays a checklist of INSTALLED/MISSING packages with descriptions of what each provides. A forceShowUpsell debug toggle on the component lets you test this panel even with all packages installed.

Tabs 1–4: Skills, Trees, Loadout, Combos

Same functionality as the ARPG demo. Uses "Souls" instead of "Gold" for the Soulslike theme.

Tab 5: Items

Browses all items from assigned SIF databases. Shows item name, code, description, properties (categories, flags, numerics, texts reflected from the item database), and skill connections — which skills grant, require, produce, or consume this item.

Tab 6: Enemies

Browses all enemies from assigned SEF databases. Shows enemy name, code, description, info (properties reflected from the enemy database), and skill connections — which skills are taught by, trained by, or summoned by this enemy.

Tab 7: Quests

Browses all quests from assigned SQF databases. Shows quest name, code, description, and skill connections — which skills this quest unlocks or rewards.

Cross-Forge Reflection

The Soulslike demo uses FindType() to scan all loaded assemblies for SIF/SEF/SQF interfaces. It builds lookup dictionaries (code → name, code → description) and reverse lookups (item → skills that reference it) via reflection at startup. No hard dependencies on any companion package.

Generating Demo Scenes

ARPG Demo

Soulslike Demo

Assigning Databases

After generating a demo canvas, select the root canvas GameObject in the Hierarchy. The demo component will be attached with empty database array fields:

ARPG Demo (SkillDemo component)

Soulslike Demo (SoulslikeSkillDemo component)

Troubleshooting

Common issues and their solutions when working with Simple Skill Forge.

Generation Issues

"Generation seems stuck" / Nothing happens after clicking Generate

Simple Skill Forge uses two-phase generation. Phase 1 generates C# scripts, which triggers a Unity domain reload (recompilation). Phase 2 runs automatically after the reload to create the ScriptableObject asset. This process can take 5–30 seconds depending on your project size.

"The generated .asset file is empty"

This typically means Phase 2 failed. Check the Console for errors. Common causes:

• A compile error in your project prevented the domain reload from completing.
• The SessionState keys were lost (rare, usually caused by a Unity crash during generation).

Fix: Delete the generated Scripts/ folder, fix any compile errors, and re-run the wizard.

"Duplicate code" validation error

Every entry code must be unique within a database and must be a valid C# identifier (letters, digits, underscores; cannot start with a digit). Use SCREAMING_SNAKE_CASE for consistency: FIREBALL, DARK_SLASH, HEAL_OVER_TIME.

"Output path does not exist"

The output folder must exist before generation. Create it manually in your Assets folder, or use the Browse button in Step 4 to select an existing folder.

Editor Issues

The generated custom inspector shows "Element 0, Element 1" instead of property names

This can happen if the database was generated with an older version of the editor generator. Re-run the wizard to regenerate the editor script.

Cross-forge sections (SIF/SEF/SQF) appear in the inspector even without companion packages

The generated editor uses Type.GetType() bridge checks to gate cross-forge sections. If sections appear without the companion package installed, regenerate the database — the editor generator has been updated to include proper bridge detection.

Property definitions changed but entries are out of sync

When you add/remove/reorder property definitions in Step 2, the wizard automatically syncs all entries. However, if you modify the generated database asset manually, the sync won't apply. Use the wizard for all structural changes.

Runtime Issues

SimpleSkillTreeTracker throws "Tree not initialized"

Call InitializeTree(treeCode) for each tree before attempting to unlock nodes or query state. The tracker does not auto-initialize — this is intentional so you can control which trees are active.

SimpleSkillBarManager set bonuses not activating

Set bonuses require the correct number of distinct skills equipped. Equipping the same skill in multiple slots does not count multiple times. Check GetEquippedCount(setCode) to verify.

SimpleSkillComboTracker drops combos unexpectedly

Combos have timing windows defined by maxDelay on each step. If you cast skills too slowly, the combo will drop. Set maxDelay to 0 to disable timing for a step. Also ensure you're passing consistent Time.time values to OnSkillUsed().

Prerequisite checks always return false

SimpleSkillHelper.CheckPrerequisite() requires a Func<string, float> value provider that returns the current value for any prerequisite target code. Common mistake: the provider returns 0 for all codes because it doesn't check the right dictionary.

Integration Issues

SAF/SIF/SEF/SQF bridge not detecting installed package

Bridge detection uses two paths:

1. UPM path: versionDefines in .asmdef files detect packages by com.livingfailure.* package name and set scripting defines automatically.
2. Non-UPM path: [InitializeOnLoad] detector classes use Type.GetType() to probe for companion types and set scripting defines manually.

If detection fails, check that the companion package's .asmdef files are present and correctly named. For Asset Store imports, ensure the folder structure matches the expected layout.

Character class restrictions not showing in the wizard

Class names come from SAF Character Template assets assigned in Step 1. If you don't have SAF installed or haven't assigned any character template assets, the class restriction section will be empty. You can still manually type class names in the builder.

Cross-forge reference dropdowns are empty

Cross-forge dropdowns in Step 3 are populated from linked databases assigned in Step 1. If you haven't assigned any SIF/SEF/SQF databases, the dropdowns will only show manual code entry fields.

Demo Scene Issues

ARPG Demo: "Assign all databases to SkillDemo component"

After running Window > Living Failure > Simple Skill Forge > Generate Skill Demo, you need to manually assign your generated database ScriptableObjects to the SkillDemo component in the Inspector. Drag your Skill, Tree, Set, and Combo database assets into the corresponding array fields.

Soulslike Demo: Shows upsell panel instead of main UI

The Soulslike demo requires all 4 companion packages (SAF, SIF, SEF, SQF) to be installed. If any are missing, it shows an upsell panel explaining what's needed. Install the missing packages and re-enter Play mode.

Soulslike Demo: "forceShowUpsell" is checked

The SoulslikeSkillDemo component has a debug toggle forceShowUpsell. Uncheck it in the Inspector to show the main UI even when all bridges are detected.

Demo scroll views don't scroll

Ensure the EventSystem exists in the scene. The generator creates one automatically, but if you deleted it, scrolling won't work. Add GameObject > UI > Event System.

FAQ

Can I have multiple skill databases in one project?

Yes. Run the wizard multiple times with different database names. Each run generates its own enum, database class, and editor. At runtime, cast each ScriptableObject to ISimpleSkillDataSource and merge or query them independently.

Can I modify the generated database asset in the Inspector?

Yes. The generated custom editor provides a full split-panel builder with search, sort, filter, and pagination — identical to the wizard's Step 3. You can add, remove, edit, and duplicate entries directly in the Inspector without reopening the wizard.

Does SSF support multiplayer / networking?

SSF generates data assets and provides runtime state trackers. The trackers (SimpleSkillTreeTracker, SimpleSkillBarManager, SimpleSkillComboTracker) are pure C# classes with snapshot serialization. You can serialize their state via CreateSnapshot() / RestoreFromSnapshot() for network sync, save/load, or undo/redo.

What's the performance impact?

Generated databases are standard Unity ScriptableObjects with struct arrays. All runtime lookups use linear scans over small arrays (typical game databases have 50–500 entries). The trackers use dictionaries for O(1) state lookups. There are no per-frame allocations in normal usage.

Can I use SSF with Addressables / Asset Bundles?

Yes. The generated database is a standard ScriptableObject and works with any Unity asset loading system. Cast the loaded asset to the appropriate interface at runtime.

About Simple Skill Forge

Simple Skill Forge is a Unity Editor tool for creating ScriptableObject-based skill databases using a wizard-driven workflow. It follows the same proven architecture as Simple Enemy Forge, Simple Item Forge, and Simple Quest Forge — dynamic property systems, two-phase code generation, schema export/import for AI-assisted content creation, and optional integration bridges via safe reflection.

Whether you're building a small indie RPG or a large-scale MMO, Simple Skill Forge adapts to your game's needs. You define the properties that matter to your game (there are no hardcoded "Mana Cost" or "Cooldown" fields), and the tool generates production-ready code and data assets from your design.

Design Philosophy

The Forge Ecosystem

Simple Skill Forge is part of the Simple Forge Ecosystem, a family of Unity Editor tools that share a common architecture:

Every package in the ecosystem follows the same 5-step wizard pattern, uses the same dynamic property system, generates the same output structure (enum + database + editor + asset), and supports the same AI schema export/import workflow.

What Gets Generated

Each forge generates 4 files per database run:

The generated database implements the corresponding interface (ISimpleSkillDataSource, ISimpleSkillTreeDataSource, ISimpleSkillSetDataSource, or ISimpleSkillComboDataSource), so your game code only depends on the interface — never on the generated class name.

Companion Products

Simple Skill Forge optionally integrates with these companion packages via safe reflection. No hard dependencies — install them only when you need them:

Version History

Support

Simple Skill Forge is developed and maintained by Living Failure.

Found a bug? Have a feature request? Email us or leave a review on the Asset Store page.