Installation - Simple Skill Forge

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

1 Open Window > Package Manager in the Unity Editor.

2 Click the + button in the top-left corner and select Add package from git URL...

3 Enter the repository URL:

https://github.com/LivingFailure/com.livingfailure.simple-skill-forge.git

4 Click Add. Unity will download and import the package automatically.

Option B — manifest.json

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

{
  "dependencies": {
    "com.livingfailure.simple-skill-forge": "https://github.com/LivingFailure/com.livingfailure.simple-skill-forge.git",
    ...
  }
}

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

Tip: To lock to a specific version, append #v1.0.0 (or any tag/branch) to the Git URL.

Asset Store

Simple Skill Forge is available on the Unity Asset Store.

1 Open the Unity Asset Store in your browser or the Unity Editor (Window > Asset Store).

2 Search for "Simple Skill Forge" by Living Failure.

3 Click Add to My Assets, then open Window > Package Manager, switch to My Assets, find Simple Skill Forge, and click Import.

4 In the Import dialog, ensure all files are selected and click Import.

The package will be placed under Assets/SimpleSkillForge/.

Manual Import

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

1 In Unity, go to Assets > Import Package > Custom Package...

2 Navigate to the .unitypackage file and select it.

3 In the Import dialog, ensure all files are checked and click Import.

Important: Do not move or rename the assembly definition (.asmdef) files after import. They define the SimpleSkillForge.Runtime and SimpleSkillForge.Editor assemblies and must remain in their original locations for compilation to succeed.

Verifying Installation

After installation, verify that everything is working correctly:

1 Check the menu: Open Window > Living Failure > Simple Skill Forge. You should see 4 forge entries: Skill Forge, Skill Tree Forge, Skill Set Forge, and Skill Combo Forge, plus the utility windows.

2 Open a forge: Click Skill Forge. The wizard window should appear with Step 1 (Setup) displayed. If you see the database name field, template dropdown, and linked database sections, the installation is correct.

3 Check the console: Look for any compilation errors in the Unity Console (Window > General > Console). A clean installation produces zero errors.

Success: If all 4 forge windows open without errors, Simple Skill Forge is installed 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.

Package	UPM Name	What It Unlocks in SSF
Simple Attribute Forge	`com.livingfailure.simple-attribute-forge`	Modifier assets on skills, ranks, and set bonuses. Attribute names for prerequisites. Character class restrictions via Character Template integration.
Simple Item Forge	`com.livingfailure.simple-item-forge`	Item-skill relationships: skill books (`grantedByItemCode`), weapon requirements (`requiredEquipmentCode`), crafted items (`producesItemCode`), and reagent costs (`reagentCosts[]`).
Simple Enemy Forge	`com.livingfailure.simple-enemy-forge`	Enemy-skill relationships: summon skills (`summonEnemyCode`), NPC trainers (`taughtByNPCCode`), learned-from enemies (`learnedFromEnemyCode`), faction effectiveness (`effectiveAgainstFactions[]`), and faction restrictions (`restrictedToFactionCode`).
Simple Quest Forge	`com.livingfailure.simple-quest-forge`	Quest-skill relationships: quest-gated unlocks (`unlockedByQuestCode`) and quest-rewarded skills (`rewardedByQuestCodes[]`).

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

Note: You can install and remove companions at any time. SSF gracefully disables features when a companion is removed — no compile errors, no data loss. Cross-forge reference fields simply become manual text entry instead of searchable dropdowns.

Assembly Definitions

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

Assembly	Namespace	Contents
`SimpleSkillForge.Runtime`	`SimpleSkillForge`	All runtime types: definitions (skill, tree, set, combo), interfaces (`ISimpleSkillDataSource`, etc.), helpers, trackers, evaluators, bridges
`SimpleSkillForge.Editor`	`SimpleSkillForge.Editor`	All editor types: wizard windows, wizard steps, wizard data, code generators, templates, schema export, utility windows

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:

{
  "name": "MyGame.Runtime",
  "references": [
    "SimpleSkillForge.Runtime"
  ]
}

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

{
  "name": "MyGame.Editor",
  "references": [
    "SimpleSkillForge.Runtime",
    "SimpleSkillForge.Editor"
  ]
}

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:

Companion Package	Define Symbol
`com.livingfailure.simple-attribute-forge`	`SIMPLE_ATTRIBUTE_FORGE`
`com.livingfailure.simple-item-forge`	`SIMPLE_ITEM_FORGE`
`com.livingfailure.simple-enemy-forge`	`SIMPLE_ENEMY_FORGE`
`com.livingfailure.simple-quest-forge`	`SIMPLE_QUEST_FORGE`

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