About Simple Enemy Forge
Simple Enemy Forge is a Unity Editor tool for creating ScriptableObject-based enemy databases using a wizard-driven workflow. It follows the same architecture as Simple Item Forge — dynamic property systems, two-phase code generation, schema export/import, and optional integration bridges.
Design Philosophy
Define Once, Use Everywhere
Define your enemies once in Enemy Forge, then reference them across all other forges. Squads group enemies into formations. Spawn tables select enemies by weight. Scaling profiles adjust enemy stats by level. Wave sequences orchestrate enemies over time. Behavior profiles define enemy AI rules. Factions organize enemies with relationship matrices. One enemy code threads through the entire system.
Dynamic, Not Hardcoded
There are no built-in HP, ATK, DEF, or Speed fields. You define your own property schema using Categories, Flags, Numerics, and Texts. A survival game might have Hunger and Temperature. A tower defense game might have Lane Preference and Armor Type. Your game, your properties — nothing is assumed.
Zero Runtime Cost
Generated databases are plain ScriptableObjects with struct arrays and enum types. No reflection at runtime, no dictionary lookups for basic access, no MonoBehaviour overhead. The runtime types are simple serializable structs that Unity handles natively. The only classes are the database ScriptableObjects themselves and the wave runner.
AI-First Content Pipeline
Every forge supports schema export in 3 formats (Full JSON, Light JSON, Markdown) with detailed instructions that AI models can follow to generate hundreds of enemies, squads, spawn tables, and more. Import the AI's output directly back into your wizard with validation and 3-choice conflict resolution.
The Forge Ecosystem
Seven interconnected wizards, each generating a complete database system:
| Wizard | Steps | Purpose | Depends On |
|---|---|---|---|
| Enemy Forge | 5 | Define enemies with dynamic properties, icons, descriptions, and optional SAF/SIF links | None (foundation) |
| Squad Forge | 4 | Group enemies into named squad configurations with slots, counts, and level overrides | Enemy DB |
| Spawn Forge | 5 | Design spawn tables with weighted pools, conditions, and weight modifiers | Enemy DB, Squad DB (optional) |
| Scaling Forge | 3 | Create scaling profiles that adjust enemy numerics by level using 5 formula types | Enemy DB |
| Wave Forge | 5 | Build wave sequences that orchestrate enemies and squads with timing and loop settings | Enemy DB, Squad DB (optional) |
| Behavior Forge | 4 | Define behavior profiles with condition-action rules, priorities, and cooldowns | None (uses own context definitions) |
| Faction Forge | 4 | Organize factions with an N×N symmetric relationship matrix and dynamic properties | None (standalone) |
The Dynamic Property System
Instead of hardcoded fields, SEF uses four dynamic property types that you define in Step 2 (Definitions) of each wizard:
| Type | Definition | Storage | Example |
|---|---|---|---|
| Categories | Label, entries list, allow multiple selection | int[] categoryValues |
Enemy Type (Undead, Beast, Demon), Rank (Minion, Elite, Boss), Element (Fire, Ice, Lightning) |
| Flags | Name, default value | bool[] flagValues |
Is Boss, Is Flying, Is Undead, Has Ranged Attack, Is Immune to Stun |
| Numerics | Name, isRange, isInteger, min/max limits | float[] numericValues |
HP, Attack Power, Defense, Aggro Range, Movement Speed, XP Reward |
| Texts | Name, line count | string[] textValues |
Lore, Weakness Hints, Flavor Text, AI Notes, Death Dialogue |
What Gets Generated
Each forge generates 3 C# files and 1 asset file:
| File | Description |
|---|---|
{Prefix}Type.cs |
Enum with one entry per item code (e.g., MyEnemyType.GOBLIN_WARRIOR).
Provides compile-time safety and IDE autocomplete. |
{Prefix}Database.cs |
ScriptableObject class implementing the data source interface (e.g.,
ISimpleEnemyDataSource). Contains the data arrays, metadata arrays for
property definitions, and all interface method implementations. |
{Prefix}DatabaseEditor.cs |
Custom Inspector editor with split-panel layout, search, sort, filter, multi-select, bulk operations, and pagination. Generated in the Editor assembly. |
{Prefix}Database.asset |
The actual ScriptableObject asset file containing all your data. Created in phase 2 of the two-phase generation process. |
AssetDatabase.Refresh() to trigger Unity's domain reload. Phase 2 runs via
[InitializeOnLoad] after recompilation, reads the data from a temporary JSON file
stored via SessionState, and creates the .asset file.
Integration
Simple Enemy Forge integrates with two optional companion packages using reflection bridges — never conditional compilation or hard assembly references:
Simple Attribute Forge (SAF) — Modifier References
When SAF is detected in the project, enemy definitions gain a modifiers array
for attaching SAF attribute modifier ScriptableObjects. This is a modifier-only
integration (lighter than SIF's full attribute system). Useful for buffs, debuffs, auras, and
stat modifications that enemies apply during combat.
Simple Item Forge (SIF) — Loot Table Linking
When SIF is detected, enemy definitions gain lootTableCode and
lootTable fields for linking to SIF loot tables. This lets enemies reference
drop tables so they can drop items on defeat. The bridge uses ISimpleLootDataSource
detection via reflection.
Generated Custom Editors
Every forge generates a professional custom Inspector editor alongside the database. These editors share a consistent feature set:
- Split-panel layout — Item list on the left (280px), detail panel on the right with 8px horizontal padding
- Search — Filter items by name or code with real-time search
- Sort — Sort by name, code, or any property (ascending/descending)
- Filter — Filter by category value, flag state, or numeric range
- Multi-select — Checkbox selection for bulk operations
- Bulk operations — Delete selected, duplicate, reorder
- Pagination — Toggle between Show All and paginated view with configurable page size
- Foldouts — Collapsible sections for each item with persistent foldout state via EditorPrefs
- ReorderableLists — Drag-to-reorder with +/- buttons for nested data (slots, entries, conditions, rules)
- Open Wizard button — Quick link to open the corresponding forge wizard from the Inspector
Version History
v1.0 — Initial Release
- 7 Forge Wizards — Enemy (5 steps), Squad (4 steps), Spawn (5 steps), Scaling (3 steps), Wave (5 steps), Behavior (4 steps), Faction (4 steps)
- Dynamic Property System — Categories, Flags, Numerics, Texts across all forges
- Two-Phase Generation — Scripts + domain reload + asset creation for all 7 forges
- Generated Custom Editors — Split-panel Inspectors with search, sort, filter, pagination, and bulk operations
- Schema Export/Import — Full JSON, Light JSON, and Markdown export for all 7 forges, with JSON import and 3-choice conflict resolution
- 6 Genre Templates — RPG, Soulslike, Survival, Tower Defense, Sci-Fi, RTS with pre-configured property definitions
- 7 Runtime Helpers — SimpleSpawnRoller, SimpleSpawnContext, SimpleSpawnEvaluator, SimpleScalingHelper, SimpleWaveRunner, SimpleBehaviorEvaluator, SimpleFactionHelper
- SAF Bridge — Reflection-based modifier reference integration
- SIF Bridge — Reflection-based loot table linking integration
- Bestiary Demo — 7-tab interactive data browser with spawn rolling, scaling preview, wave simulation, behavior evaluation, and faction matrix display
- 97 C# files — 23 Runtime + 74 Editor
Support
Self-Help Resources
- Troubleshooting Guide — Solutions for common generation, import, wizard, and editor issues
- API Reference — Complete runtime API documentation for all 7 forges and runtime helpers
- Quick Start Guide — Create your first enemy database in under 5 minutes
Get in Touch
- Unity Asset Store — Leave a review or ask questions on the Simple Enemy Forge Asset Store page
- Email — Contact the developer at
livingfailuregames@gmail.com - Website — livingfailuregames.com