Item Generator System

Item Generator System is a complete framework for procedurally generating

RPG items in Unity. Define rarity tiers, stat pools, affix restrictions,

and name templates — then roll Diablo-style loot as runtime objects or

ScriptableObject assets, entirely from C# or the built-in 4-tab Editor

Window.

Designed to feel familiar to anyone who has played Diablo, Path of Exile,

or Last Epoch. Items have a rarity tier, a base stat pool, implicit

modifiers, randomly rolled affixes, optional sockets, and (for the rarest

items) a unique legendary effect with a flavor name.

NOTE ON THIRD-PARTY & AI-GENERATED CONTENT

The 10 example item icons in ExampleContent/Icons/ are AI-generated

(Leonardo.Ai, paid commercial tier). The demo cards use the Cardo and

Cinzel fonts under the SIL Open Font License 1.1. All source code,

ScriptableObject definitions, the runtime engine, Editor Window, demo

scene, custom inspectors, unit tests, and User Manual are original work

by Null Bolt Studio. Full transparency notice below; see Third-Party

Notices.txt in the package for the consolidated attribution list.

KEY FEATURES

- Rarity System — 6 default tiers (Common → Unique). Per-rarity affix

  counts, socket ranges, stat multipliers, sell value scaling,

  legendary-effect flags. Fully data-driven via ScriptableObjects.

- Stat Pool Filtering — Each item type and sub-type controls exactly

  which stats can roll, preventing illogical combinations (melee weapons

  never roll spell stats).

- Sub-Type Inheritance — Four modes: Inherit, Override, Extend, Restrict.

  Axes inherit weapon stats but restrict attack speed; staves override to

  a spell-only pool entirely.

- Affix System — Weighted random affixes with type/rarity restrictions,

  exclusion groups, minimum-rarity gating, and stat-uniqueness

  enforcement per item.

- Common-Tier Affixes — Common items roll 0–2 low-value minor affixes

  and 0–1 sockets. Minor affixes locked to Common so they never appear

  on higher tiers.

- Unique-Tier Templates — 4 example Unique-only templates ship with

  pre-filled legendary effects (Doombringer, Skullsplitter, Stormcaller,

  Heartwarden). Demonstrates the recommended pattern for designer-

  authored unique items.

- Name Generation — Per-rarity prefix/suffix pools with type and

  sub-type filters. Material prefixes restricted to Common; fantasy

  prefixes to Magic+. Unique name pool with automatic article prepending.

- Dual Output — Items as runtime ItemInstance (JSON-serializable) or

  ItemDefinition (ScriptableObject asset).

- Editor Window — 4-tab interface: Generate, Templates, Browser,

  Configuration. Live item card preview in the Generate tab.

- Deterministic — Same seed always produces the same item, cross-

  platform, via Unity.Mathematics.Random.

- Post-Generation Callbacks — Hook into ItemGeneratorCallbacks

  .OnPostGenerate to modify items after generation (seasonal bonuses,

  difficulty scaling, etc.).

- Example Content — One click generates 15 stats, 6 rarities, 4 item

  types, 14 sub-types, 25 affixes, 14 templates (10 standard + 4

  Unique-only), and a full name configuration.

- Demo Scene — Runtime Diablo-style card UI with rarity-tinted borders,

  procedural glow, sockets and legendary sections.

WHAT'S INCLUDED

- Full source code for the runtime engine and Editor Window

- 9 ScriptableObject types with custom inspectors

- Demo scene with item card prefab

- 25-page User Manual (PDF)

- Setup Wizard that auto-installs UPM dependencies on first import

- Unit tests covering determinism, stat resolution, and affix filtering

- Cardo and Cinzel SDF fonts (SIL OFL 1.1 licensed) for the demo cards,

  with bundled OFL.txt license text

- Consolidated Third-Party Notices.txt at the package root

TECHNICAL HIGHLIGHTS

- Pure C# — no native plugins, no platform restrictions

- Decoupled — generation engine has zero UI dependencies; demo cards

  are optional and can be deleted

- Deterministic seeded RNG — same input always produces same output, on

  every platform

- JSON-serializable runtime objects via JsonUtility for save/load

- Asmdef-isolated Editor / Runtime / Demo / Tests with clean assembly

  boundaries

- Auto-discovery and validation tools for content management

COMPATIBILITY

Unity 2022.3 LTS, Unity 2023, Unity 6 (6000.0+). Pipeline-agnostic —

works with Built-in, URP, and HDRP.

Required UPM packages (auto-installed on first import via the included

Setup Wizard, except where Unity bundles them already):

- com.unity.mathematics — required by the core generation engine

- com.unity.inputsystem — required by the demo scene (UI input module)

- TextMeshPro — required by the demo scene. Installed automatically on

  Unity 2022.3 LTS / Unity 2023 via the com.unity.textmeshpro package.

  On Unity 6 it is included with com.unity.ugui (already present) — no

  separate install required.

DOCUMENTATION & SUPPORT

The package ships with a comprehensive 25-page User Manual (PDF) and a

guided Setup Wizard that walks through TMP Essentials import, example-

content generation, demo-scene build, and font validation on first

import.

THIRD-PARTY CONTENT & AI DISCLOSURE

Example item icons (ExampleContent/Icons/ — sword, axe, staff, grimoire,

helm, boots, vest, chest, ring, shield) were generated with Leonardo.Ai

(DreamShaper XL model) under a paid commercial tier. Each icon was

hand-reviewed before inclusion.

Demo cards use the Cardo and Cinzel fonts under the SIL Open Font

License 1.1 (full text at Demo/Fonts/OFL.txt).

All C# source code, ScriptableObject definitions, the runtime engine,

the Editor Window, demo scene, custom inspectors, unit tests, and User

Manual are original work by Null Bolt Studio.

See Third-Party Notices.txt at the package root for the consolidated

attribution list.

ABOUT NULL BOLT STUDIO

Null Bolt Studio creates code-oriented Unity tools and systems for

serious game developers. Visit nullbolt.com to see other releases.