Installation

Get Simple Enemy Forge set up in your Unity project.

Prerequisites

• Unity 2021.3 LTS or newer
• Basic familiarity with the Unity Editor and ScriptableObjects

Import from Unity Asset Store

Folder Structure

Menu Items

After installation, these menu items are available under Window → Simple Enemy Forge:

SAF Integration (Optional)

If Simple Attribute Forge (sold separately) is installed in the same project, Simple Enemy Forge automatically detects it and unlocks modifier references on enemy definitions. This allows you to attach SAF attribute modifiers directly to enemies — useful for buffs, debuffs, auras, and stat modifications that enemies apply during combat. Detection is fully automatic — just import both packages and the features appear. You can add or remove SAF at any time with zero compilation errors.

See the SAF Integration page for full details on features, the detection lifecycle, and what happens when you install or remove SAF.

SIF Integration (Optional)

If Simple Item Forge (sold separately) is installed in the same project, Simple Enemy Forge automatically detects it and unlocks loot table linking on enemy definitions. This allows you to assign SIF loot tables to enemies so they can drop items on defeat. Detection is fully automatic — just import both packages and the features appear. You can add or remove SIF at any time with zero compilation errors.

See the SIF Integration page for full details on features, the detection lifecycle, and what happens when you install or remove SIF.

Next Steps

You're all set! Head to the Quick Start Guide to create your first enemy database in under 5 minutes.

Quick Start Guide

Create a complete enemy database in under 5 minutes. This walkthrough covers the Enemy Forge wizard — the foundation everything else builds on.

Prerequisites

• Unity 2021.3 or newer
• Simple Enemy Forge package imported

5-Step Creation Process

Example: Dark Fantasy Enemies

Step 1: Setup

Step 3: Create Enemies

Step 5: Generate

After generation, your project will contain:

Using Your Enemies in Code

Access Your Data

The generated database ScriptableObject provides methods to access your enemies:

Property indices match the order you defined them in Step 2. For example, if “HP” is the first numeric property you defined, it will be at numericValues[0].

Interface-Based (Generic Code)

The Generated Custom Editor

Your database asset gets a professional custom Inspector with:

• Split panel — Enemy list on the left, enemy editor on the right
• Search — Filter by name or code
• Sort — Name A-Z/Z-A, Code A-Z/Z-A
• Category filter — Show only Humanoids, only Undead, etc.
• Multi-select — Checkbox per enemy for bulk Delete, Duplicate, Set Icon
• Pagination — Handles 300+ enemies smoothly

No more "Element 0", "Element 1" in the Inspector. Every property shows its real name.

Next Steps

Enemy Forge Wizard

The Enemy Forge is the foundation wizard of the entire Simple Enemy Forge ecosystem. Every enemy you create here becomes available to Squad Forge (as squad members), Spawn Forge (as spawn entries), Scaling Forge (as scaling targets), Wave Forge (as wave entries), Behavior Forge (as behavior subjects), and Faction Forge (as faction members). The Enemy Forge is always your starting point — define your enemies once, use them everywhere.

Open the wizard via Window › Simple Enemy Forge › Enemy Forge Wizard. It walks you through a 5-step process to define your enemy properties, create enemies, configure output paths, and generate a complete database with type-safe enums and a custom Inspector editor.

The wizard produces a ScriptableObject-based enemy database that is fully data-driven. Nothing is hardcoded — there is no built-in "HP" stat, no predefined "Rank" dropdown, no assumed "Aggro Range" field. You define every property your enemies need using four flexible types, and the system works for any genre: RPG, soulslike, survival horror, tower defense, sci-fi, RTS, or anything else you can imagine.

The Dynamic Property System

At the heart of the Enemy Forge is a dynamic property system that lets you define the exact shape of your enemy data. Rather than working around a rigid, genre-specific schema, you build a property system that matches your game perfectly. A fantasy RPG might need "Enemy Type" and "Base HP"; a soulslike might need "Poise" and "Stagger Threshold"; a tower defense might need "Speed" and "Armor Type". The Enemy Forge handles all of these through four property types.

Internally, each enemy stores parallel arrays whose indices map to the definitions you create in Step 2. For example, if you define three categories — "Enemy Type" at index 0, "Rank" at index 1, and "Element" at index 2 — then every enemy has a categoryValues[] array of length 3, where categoryValues[0] holds the Enemy Type selection, categoryValues[1] holds the Rank selection, and so on. The same pattern applies to flags, numerics, and texts.

This architecture means you can add, remove, or reorder property definitions at any time during development. When you add a new category, the SyncAllEnemiesWithDefinitions() method automatically extends every enemy's arrays to match. When you remove a property, the arrays shrink. The wizard keeps your data in sync so you never end up with mismatched array lengths.

Genre Templates

Step 1 of the wizard offers a template dropdown that pre-populates your property definitions with genre-appropriate categories, flags, numerics, and texts. Templates are a starting point — you can freely modify, add, or remove any property after applying a template. They are designed to save you the work of researching what properties a typical game in that genre needs.

Each template also includes example enemies that demonstrate realistic property values. These examples serve as reference data for AI content generation — when you export your schema, AI models can see how properties are used in practice and generate consistent, well-structured enemies.

All templates use generic, non-trademarked terminology and are safe for commercial use. No template references specific game names, trademarked abilities, or copyrighted content.

Step 1 — Setup

The Setup step configures the basic identity of your enemy database. Everything you set here determines the names of the generated files, the C# namespace they live in, and which genre template (if any) pre-populates your property definitions. Take a moment to choose meaningful names — they will appear throughout your codebase once generation is complete.

Database Configuration

Template Selection

Below the database configuration, you will find the Template Selection section. Choose a genre template from the dropdown to pre-populate your definitions with genre-appropriate properties, or select None (Start Fresh) to define everything from scratch. When a template is selected, the wizard displays a description of the template, the number of categories, flags, numerics, texts, and example enemies it includes. Templates can be freely modified after selection — they are a starting point, not a constraint.

Simple Attribute Forge Integration

If the Simple Attribute Forge package is installed in your project, an additional section appears in Step 1 titled "Simple Attribute Forge Integration". When SAF is detected, enemies gain the ability to reference modifier assets — ScriptableObject references to modifier assets created with Simple Attribute Forge's Modifier Wizard. These modifiers represent buffs, debuffs, or status effects that the enemy can apply to the player (e.g., a "Poison" modifier on a snake enemy, a "Burning" modifier on a fire elemental).

Simple Item Forge Integration

If the Simple Item Forge package is installed in your project, an additional section appears that enables loot table linking. Each enemy can be assigned a lootTableCode that references a loot table from SIF's Loot Forge. This creates a direct connection between enemies and their drop tables — when an enemy is defeated, your game logic can look up the enemy's loot table code and roll against it to determine item drops.

Generated Names Preview

The bottom of Step 1 shows a Generated Names Preview that reflects your current configuration. Based on your class prefix (and suffix, if enabled), it displays three generated names: the Enum ({GP}Type), the Database ({GP}Database), and the Asset ({GP}Database.asset). The custom editor name is not shown here. This lets you verify your naming before proceeding.

Validation

A validation panel at the very bottom checks your configuration in real time. It reports errors (empty database name, invalid C# identifiers) and warnings (empty namespace, existing files that will be overwritten). You cannot proceed to the next step until all errors are resolved.

Step 2 — Definitions

This is where you design the "shape" of your enemy data. Every property you define here becomes available on every enemy in Step 3. If you selected a genre template in Step 1, the definitions will already be populated — you can modify, add, or remove any of them. If you started fresh, this step begins empty and you build your property system from scratch.

Each section uses a ReorderableList with drag-and-drop reordering and a count field in the header for quick bulk creation. Type a number into the count field and press Enter to instantly create that many entries, which you can then fill in.

Categories

Categories are dropdown menus your enemies will use. They are the most structured property type, ideal for classification and filtering. Each category definition has three components:

• Label — The display name shown in the UI (e.g., "Enemy Type", "Rank", "Element", "Movement Type")
• Entries — The list of options the user picks from. Each entry is a string (e.g., "Humanoid", "Undead", "Beast"). Entries are displayed in a nested ReorderableList within each category, so you can drag to reorder them. The count field in the entries header lets you create many entries at once.
• Allow Multiple — A toggle that changes how the category behaves:
  • OFF (default) — Single-select dropdown. The user picks exactly ONE value. A default entry applies to new enemies. The value is stored as a single integer index.
  • ON — Multi-select checkboxes. The user can pick MULTIPLE values simultaneously. There is no single default. The values are stored as an array of selected indices (using SimpleIntArray for Unity serialization).

For example, an "Element" category with Allow Multiple ON and entries [Fire, Ice, Lightning, Poison] lets an enemy have both "Fire" and "Ice" selected simultaneously, which is perfect for dual-element bosses. Meanwhile, an "Enemy Type" category with Allow Multiple OFF ensures every enemy is classified as exactly one type.

Flags

Flags are boolean on/off toggles. They are the simplest property type, perfect for binary states that either apply to an enemy or do not. Each flag definition has two components:

• Name — The display name (e.g., "Is Boss", "Is Flying", "Is Undead", "Has Shield", "Can Summon")
• Default Value — The initial on/off state for newly created enemies. Most flags default to false, but you might want a flag like "Is Hostile" to default to true.

In Step 3, flags appear as a vertical list of toggle checkboxes (one flag per row, full-width ToggleLeft). They are also useful for Behavior Forge conditions — a behavior rule might check "Is Flying" to determine whether to use a ground attack or aerial attack pattern.

Numerics

Numeric properties store number values with configurable constraints. They are the most versatile property type, handling everything from HP to aggro range to XP rewards. Each numeric definition has these components:

• Name — The display name (e.g., "HP", "Attack", "Defense", "Aggro Range", "XP Reward")
• Type — Integer or Float. Integer properties show IntField in the editor; float properties show FloatField. Choose integer for whole numbers like HP, damage, or XP. Choose float for decimal values like speed multipliers, aggro range, or critical chance.
• Is Range — When OFF, the property stores a single value. When ON, the property stores a min/max pair, which is useful for damage ranges (e.g., "10-25 damage"), patrol distances, or any property that naturally varies between two bounds. Range values are stored in two parallel arrays: numericValues[] for the min and numericRangeMaxValues[] for the max.
• Min / Max Constraints — Hard limits that the value(s) must stay within. For example, "HP" might be constrained to 1–99999, while "Critical Chance" might be constrained to 0.0–1.0. These constraints are enforced in the wizard UI with clamped fields.
• Default Value(s) — The starting value for new enemies. For range properties, there is a default min and a default max.

Texts

Text properties store free-form string content. They are ideal for lore, weakness hints, battle cries, ability descriptions, or any content that does not fit neatly into a category, flag, or number. Each text definition has two components:

• Name — The display name (e.g., "Lore", "Weakness Hints", "Battle Cry", "Special Ability")
• Line Count (1–6) — Controls the UI height of the text field in Step 3 and in the generated custom editor. A lineCount of 1 renders a compact single-line TextField. A lineCount of 2 or higher renders a multiline TextArea whose height scales with the lineCount value. Use 1 for short labels like "Battle Cry" or "Patrol Zone". Use 3 or higher for longer content like "Lore" or "Combat Strategy Notes".

Schema Export / Import

At the top of Step 2, four buttons provide the Schema Export/Import system for AI-assisted content generation:

• Export Full JSON — Exports a comprehensive JSON file containing all definitions, all existing enemies, comprehensive AI instructions (what it can do, what it cannot do, property guidance, balance tips, ecosystem overview), and SAF modifier data plus SIF loot table data if available. This is the most complete export — an AI model receiving this file has everything it needs to generate enemies that perfectly match your property system.
• Export Light JSON — Exports definitions and instructions only, with an empty enemies array and no integration data. The instructions tell the AI to ask you for context before generating. This mode is much smaller and useful when you want the AI to be interactive rather than just filling in data.
• Export Markdown — Exports a human-readable Markdown document ideal for pasting directly into ChatGPT, Claude, or any LLM chat interface. Contains the same information as Full JSON but formatted as tables, bullet points, and code blocks for easy reading.
• Import Schema (JSON) — Reads a JSON file and populates both definitions and enemies. Supports the schema format produced by the export buttons. The import system validates enemy codes, maps category/flag/numeric values by name, detects duplicates, and reports skip reasons for any entries that fail validation. After import, a popup shows the count of imported and skipped enemies.

See the AI Workflow page for the full schema export/import guide, including the exact JSON format, tips for working with AI models, and the phased generation workflow.

Step 3 — Enemies

This is where you create and edit your enemies using the properties defined in Step 2. The interface uses a split-panel layout with an enemy list on the left and the enemy editor on the right. Select an enemy from the list to view and edit its properties. The wizard provides a rich set of tools for searching, filtering, sorting, and bulk-editing enemies.

Left Panel — Enemy List (280px)

The left panel contains the master enemy list with several tools above it:

• Search bar + Find button — Type a search term to filter enemies by name or code. The status text shows the match count (e.g., "12 matches of 87"). Click the Find button to cycle through matching enemies one by one, automatically selecting and scrolling to each match.
• Category filter — Two dropdown menus that work together. The first dropdown selects which category to filter by (e.g., "Enemy Type", "Rank"). The second dropdown selects which specific value within that category to show (e.g., "Undead", "Boss"). Only enemies matching the selected category value are displayed. Both dropdowns include an "(All)" option to show everything.
• Sort dropdown — Five options: None (original order), Name A-Z, Name Z-A, Code A-Z, Code Z-A. Sorting reorders the actual enemy data for consistent ordering.
• Multi-select toolbar — A row of bulk operation buttons:
  • Select All toggle — Selects or deselects all currently visible (filtered) enemies
  • Delete button — Deletes all selected enemies after a confirmation dialog
  • Duplicate button — Duplicates all selected enemies, appending " (Copy)" to each name and "_COPY" to each code
  • Set Icon button — Opens a sprite picker to assign the same icon to all selected enemies at once. This is invaluable for batch icon assignment — select all undead enemies, click Set Icon, pick a placeholder sprite.
• Status bar — Shows "Showing X of Y | Z selected" at the bottom of the list area, giving you a quick count of visible enemies, total enemies, and selected enemies.
• ReorderableList — The enemy list itself supports drag-and-drop reordering and has a count field in the header for quick bulk creation. Each enemy row shows a checkbox (for multi-select) and the enemy name. The [+] button at the bottom adds a new empty enemy.
• Pagination — A "Show All" toggle (on by default) controls pagination. When unchecked, enemies are paginated with a configurable "Per Page" count and page navigation buttons ([<] Page X of Y [>]). This keeps the list responsive with large databases.

Right Panel — Enemy Editor

Select an enemy from the list to edit it in the right panel. The editor shows all of the enemy's properties organized into collapsible sections:

Identity Section (Always Visible)

• Name — The display name of the enemy (e.g., "Goblin Warrior", "Shadow Drake"). This is the name shown in-game.
• Code — The unique identifier used in code (e.g., GOBLIN_WARRIOR, SHADOW_DRAKE). Codes must be valid C# identifiers and are typically written in UPPER_SNAKE_CASE. The Auto button next to the code field converts the enemy name to UPPER_SNAKE_CASE automatically, handling spaces, invalid characters, and leading digits.
• Description — A TextArea for the enemy's description or lore text.
• Icon — A Sprite ObjectField for the enemy's portrait or sprite, shown with a 70x70 preview thumbnail.

Categories Section (Collapsible)

Shows a header with the count (e.g., "Categories (4)") and a foldout arrow. When expanded, each category is displayed according to its Allow Multiple setting:

• Single-select categories show a dropdown menu with all entries
• Multi-select categories show a grid of checkboxes, one for each entry

The section is always visible regardless of how many categories exist.

Flags Section (Collapsible)

Shows all flags as a vertical list of toggle checkboxes — one flag per row, full-width ToggleLeft. Each toggle is labeled with the flag name. The header shows the count (e.g., "Flags (6)"). If no flags are defined, the section shows "No flags defined." as a placeholder. This is the only section in the wizard that displays a placeholder when its definition count is zero.

Numerics Section (Collapsible)

Shows each numeric property with the appropriate field type. Single values display as an IntField or FloatField (depending on the isInteger setting). Range values display with separate Min and Max fields arranged vertically, with the property name as a label above. All values are clamped to the constraints defined in Step 2. The header shows the count (e.g., "Numeric Properties (12)").

Texts Section (Collapsible)

Shows each text property with a UI field sized according to lineCount. Properties with lineCount=1 display as a single-line TextField. Properties with lineCount=2+ display as a multiline TextArea whose height scales with the lineCount value. Text areas with content exceeding the fixed height show an inner scrollbar for overflow. The header shows the count (e.g., "Text Properties (2)").

SAF Modifiers Section (Collapsible, Conditional in Wizard)

In the wizard, this section only appears when Simple Attribute Forge is installed (hidden otherwise). In the generated custom editor, the section is always emitted in the code and auto-adapts at runtime via Type.GetType() — when SAF is installed, the ObjectField uses the correct modifier base type; when SAF is removed, it falls back to ScriptableObject. No regeneration is needed when SAF is installed or uninstalled. It contains a ReorderableList of modifier references (stored as ScriptableObject[]). These are Unity asset references that link to modifier assets created with Simple Attribute Forge's Modifier Wizard. Each entry is an ObjectField where you drag and drop a modifier asset. Example: a "Poison" modifier that applies damage over time when the enemy attacks, or a "Slow" modifier that reduces player movement speed. Note that modifiers are Unity object references and cannot be set via JSON import — they must be assigned manually or via the generated custom editor.

SIF Loot Table Section (Collapsible, Conditional in Wizard)

In the wizard, this section only appears when Simple Item Forge is installed (hidden otherwise). In the generated custom editor, the section is always emitted and auto-adapts at runtime via Type.GetType(), just like the SAF section — no regeneration needed. It contains two fields:

• Loot Table Code — A string field for the loot table code from SIF's Loot Forge (e.g., "GOBLIN_DROPS", "BOSS_DRAGON_LOOT"). When SIF is detected, this field shows a dropdown populated with available loot table codes from your SIF database.
• Loot Table — An ObjectField for a direct reference to a SIF Loot Database ScriptableObject, provided as a convenience for Inspector-based workflows.

Duplicate Enemy Button

At the bottom of the right panel, a Duplicate Enemy button creates a copy of the currently selected enemy with " (Copy)" appended to the name and "_COPY" appended to the code.

Inline Validation

The editor validates enemies in real time and shows colored messages directly in the enemy editor:

• Error — Empty name or code (the enemy cannot be generated without these)
• Error — Code is not a valid C# identifier (must be letters, numbers, underscores; cannot start with a number)
• Warning — Duplicate name or code (two enemies share the same name or the same code, which will cause issues during generation)

Step 4 — Settings

Configure where generated files are saved and which files to generate. This step gives you full control over your project's file organization.

Output Paths

A single Output Folder field with a Browse button that opens a folder picker dialog. The path must be within the Assets folder. The default is Assets/Generated/Enemies. Scripts are automatically placed in a Scripts subfolder, the custom editor in a nested Scripts/Editor subfolder, and the asset file in the output folder itself.

A Custom Paths toggle below the output folder reveals separate Scripts Folder and Assets Folder fields when enabled, each with its own Browse button. This lets you place scripts and data assets in different locations if your project structure requires it. When Custom Paths is disabled, the resolved paths are shown as read-only labels beneath the output folder field.

Code Generation Options

Two toggles control which files are generated. Each toggle shows the exact file name that will be created based on your class prefix:

File Preview

Below the toggles, a Generated File Preview section shows the full list of files that will be created based on your current selections, including their complete paths. Checkmarks indicate which files are enabled. This lets you review exactly what will be written to disk before you proceed to generation.

Step 5 — Generate

The final step. Review your complete configuration and click Generate to create your enemy database. The wizard performs a two-phase generation process that handles Unity's domain reload automatically.

Generation Summary

A read-only summary panel at the top shows all key metrics at a glance:

• Database Name, Namespace, and Template used
• Total enemy count, category count (with total entries), flag count, numeric count, text count
• Integration status (SAF enabled with modifier count, SIF enabled with loot table link count)

Files to Generate

A list of every file that will be created, with full paths. This is your final chance to review before committing.

Phase 1 — Script Generation

When you click Generate, the wizard writes all C# files to disk:

After writing the files, the wizard saves all wizard data (enemies, definitions, metadata) to a temporary JSON file at Temp/SimpleEnemyForge_PendingAssetData.json and sets a SessionState flag. It then triggers AssetDatabase.Refresh() to compile the new scripts.

Phase 2 — Asset Creation (Automatic)

Unity recompiles the new scripts, which causes a domain reload. All static variables are reset, but the SessionState flag and temp file survive. An [InitializeOnLoad] handler detects the pending flag and temp file, then uses EditorApplication.delayCall to wait until Unity is fully ready. A retry loop checks whether the generated database type is loaded, then creates the ScriptableObject asset and populates it with all enemy data and metadata arrays.

Post-Generation Actions

After successful generation, the wizard displays action buttons:

• Open Scripts Folder — Opens the generated scripts directory in your file browser
• Select Database Asset — Selects and pings the generated .asset file in the Unity Project window
• Create New Database — Resets the wizard to start fresh for a new database

What Gets Generated

The Enemy Forge generates up to 3 script files (depending on your settings in Step 4), plus the data asset. Each file serves a specific purpose in your runtime architecture.

{GP}Type.cs — Enum

A strongly-typed enum with one entry per enemy code. This provides compile-time safety and full IntelliSense support, so you never need to pass raw strings around your codebase. The enum values are generated from the enemy codes you defined in Step 3.

{GP}Database.cs — ScriptableObject

A ScriptableObject class that implements ISimpleEnemyDataSource. It contains all enemy data in serialized arrays and metadata arrays for category labels (with entries), flag names, numeric property names, and text property names. This single asset is the complete runtime representation of your enemy database.

The generated class includes implementations of all ISimpleEnemyDataSource methods: enemy access (GetEnemyByCode, GetEnemyByName), dynamic filtering (GetEnemiesByCategory, GetEnemiesByFlag, GetEnemiesByNumericRange), and metadata queries (GetCategoryLabels, GetCategoryEntries, etc.).

Accessing Your Database in Code

The generated database ScriptableObject implements ISimpleEnemyDataSource, which provides all methods you need for enemy access, filtering, and metadata queries. Assign the database asset to a serialized field on your MonoBehaviour or ScriptableObject, then call methods directly:

You can also use the ISimpleEnemyDataSource interface for polymorphic access, which is how the other forges (Squad, Spawn, Wave, etc.) interact with your enemy databases:

{GP}DatabaseEditor.cs — Custom Inspector

A custom editor generated alongside your database that replaces Unity's default Inspector (which shows unhelpful "Element 0", "Element 1" labels) with a professional split-panel editor. This editor is placed in an Editor/ subfolder so it is automatically excluded from runtime builds. It provides a full-featured editing experience directly in the Inspector window.

{GP}Database.asset — Data File

The ScriptableObject asset file containing all of your enemy data. This is the file you assign to a MonoBehaviour's serialized field or reference from any script that needs enemy data. It is a standard Unity asset that can be version-controlled, duplicated, and referenced from any scene or prefab. It is also the asset you assign to Squad Forge, Spawn Forge, Scaling Forge, Wave Forge, Behavior Forge, and Faction Forge as their linked enemy database.

Runtime Data Structures

The Enemy Forge uses a small set of runtime structs and an interface that live in the SimpleEnemyForge namespace. These types are defined in the package's Runtime/ folder and are available to all of your game scripts.

SimpleEnemyDefinition

The core enemy struct. Each enemy stores fixed identity fields and dynamic property arrays whose indices correspond to the definitions you created in Step 2.

SimpleIntArray

A wrapper struct for serializing arrays of int, since Unity cannot serialize jagged arrays directly. Used by categoryMultiValues for multi-select categories.

ISimpleEnemyDataSource

The interface that all generated enemy databases implement. It provides methods for enemy access, metadata queries, and dynamic filtering. See the API Reference page for complete method documentation.

The interface is also used by the dependent forges for multi-database merging. Squad Forge, Spawn Forge, Wave Forge, and others accept a List<ScriptableObject> of enemy databases. Each database is cast to ISimpleEnemyDataSource using the database is ISimpleEnemyDataSource pattern, and enemy codes are merged across all databases (first-database-wins for duplicates). This means you can split your enemies across multiple databases (e.g., one for dungeon enemies, another for world bosses) and link them all to a single Squad or Spawn setup.

Tips & Best Practices

Squad Forge

Squad Forge groups enemies into reusable encounter configurations. Instead of spawning individual enemies one at a time, you define squads — named compositions of enemies with counts, level overrides, and custom properties — and reference them from Spawn Forge, Wave Forge, or your own game code.

Every squad links back to one or more Enemy Databases, so enemy codes are always validated against real data. You can attach dynamic properties (Categories, Flags, Numerics, Texts) to squads themselves — independent of the properties on individual enemies.

Open the wizard via Window › Simple Enemy Forge › Squad Forge Wizard.

Overview

Squad Forge is a 4-step wizard that walks you through the entire process:

Step 1 — Setup

Link Enemy Databases

Squad Forge requires at least one Enemy Database to function. You add databases using a ReorderableList — drag to reorder, click + to add, - to remove. You can link multiple Enemy Databases; the wizard merges all enemy codes together using a first-DB-wins deduplication strategy (if two databases define the same code, the first one in the list takes priority).

The linked databases are used to:

• Populate the Enemy Browser popup when assigning enemies to squad slots
• Validate enemy codes in your squads
• Provide code autocompletion in the slot editor

Output Configuration

Step 2 — Definitions

Define custom properties that apply to squads (not individual enemies). These are separate from and independent of the properties defined in Enemy Forge.

Property Types

All four property sections are always visible in the wizard, even when no definitions exist. An empty section shows a "No X defined." placeholder.

Schema Export/Import

Four buttons at the top of the Definitions step let you exchange schemas with AI tools:

• Export Full JSON — Complete schema with all definitions, squads, and linked enemy data. Ideal for giving AI full context.
• Export Light JSON — Definitions only, no squad data. Smaller payload for when you just want AI to understand the structure.
• Export Markdown — Human-readable documentation with tables, code blocks, and examples.
• Import JSON — Import definitions and/or squads from AI-generated JSON. Presents a 3-choice dialog (Merge, Replace, Cancel) for both definitions and squads.

See AI Workflow for the complete export/import guide.

Step 3 — Squads

The main builder step uses a split-panel layout:

Left Panel — Squad List

• Search — Filter squads by name or code
• Sort — Sort alphabetically by name or code
• Multi-select — Checkbox selection for bulk operations
• ReorderableList — Drag to reorder, + to add, - to remove
• Pagination — Toggle between Show All and paginated view (configurable items per page)

Right Panel — Squad Editor

Select a squad from the list to edit its details:

Identity

Slots

Each squad contains a ReorderableList of slots. A slot defines which enemy appears and in what quantity:

Dynamic Properties

Below the slots, a Properties section appears when at least one category, flag, or numeric is defined in Step 2. It shows Categories (as dropdowns), Flags (as toggles), and Numerics (as sliders) with values specific to this squad. Text properties are not rendered in the builder step.

Duplicating Squads

To duplicate squads, use the Duplicate button in the bulk operations toolbar in the left panel. Select one or more squads via the checkboxes, then click Duplicate to copy them (including all slots and property values) with modified names.

Step 4 — Generate

Generation uses a two-phase process to handle Unity's domain reload:

Generated Files

Runtime Data Structures

SimpleSquadSlot

SimpleSquadGroup

Interface Reference — ISimpleSquadDataSource

All generated squad databases implement this interface:

Usage Example

Tips

Spawn Forge

Spawn Forge creates spawn tables with weighted pools, conditional activation, and context-aware entry selection. It is the most complex of the seven forges, combining hierarchical data (Table → Pool → Entry) with a powerful condition system that reacts to game state at runtime.

Spawn tables reference enemies from your Enemy Database and optionally squads from your Squad Database. Each entry can be either a single enemy or an entire squad group.

Open the wizard via Window › Simple Enemy Forge › Spawn Table Forge Wizard.

The wizard has 5 steps: Setup, Definitions, Spawn Tables, Settings, Generate.

Understanding the Spawn Table Hierarchy

Spawn tables use a three-level hierarchy. Each level adds its own logic:

How a Roll Works

The Condition System

Conditions check values from the current game context (passed via SimpleSpawnContext) to decide whether a pool activates or an entry is eligible. The same condition structure is used at both pool and entry level.

SimpleSpawnCondition Fields

Pool Conditions vs Entry Conditions

• Pool conditions — Gate the entire pool. If the conditions fail, none of the entries in the pool are considered. Use these for broad context checks like "only activate in nighttime" or "only at difficulty 3+."
• Entry conditions — Gate individual entries within an active pool. Use these for fine-grained control like "include Fire Dragon only when Biome is Volcano."

Condition Chaining

Multiple conditions are evaluated left-to-right. The first condition always has logic = None. Subsequent conditions use And, Or, or Not to combine with the running result:

Weight Modifier System

Weight modifiers dynamically adjust an entry's base weight based on context numeric values. This lets spawn probabilities shift with game state without needing separate condition logic.

Modifier Types

Weight modifiers stack. If an entry has multiple modifiers, they are applied sequentially. The final weight is clamped to a minimum of 0 (negative weights are not allowed).

Step 1 — Setup

Link Databases

Spawn Forge accepts two types of linked databases:

• Enemy Databases (required) — Provides enemy codes for spawn entries. You can link multiple databases; first-DB-wins deduplication applies.
• Squad Databases (optional) — Provides squad codes for entries that spawn entire groups. The squad database must itself link to an enemy database.

Output Configuration

Step 2 — Definitions

Definitions in Spawn Forge describe context properties — the game state values that conditions and weight modifiers reference. These are not stored on the spawn tables themselves; they define what the runtime context looks like.

Context Property Types

Note that Spawn Forge definitions do not include Texts — text properties are not meaningful for runtime condition evaluation.

Schema Export/Import

The same four-button export/import system as other forges. Export Full JSON includes context definitions plus all spawn table data (pools, entries, conditions, weight modifiers). Import presents a 3-choice dialog for definitions and tables. See AI Workflow.

Step 3 — Spawn Tables

The main builder step uses a split-panel layout with nested ReorderableLists:

Left Panel — Table List

• Search — Filter tables by name or code
• Sort — Sort alphabetically by name or code
• Multi-select — Checkbox selection for bulk delete
• Pagination — Toggle between Show All and paginated view

Right Panel — Table Editor

Select a table from the list to edit:

Identity

Name, Code (with Auto toggle), and Description — same pattern as all forges.

Pools

Each table contains a ReorderableList of pools. Expand a pool's foldout to see:

Entries

Each entry within a pool has:

Step 4 — Settings

Configure generation output settings — output folder path and any additional generation options. This step also shows a summary of what will be generated.

Step 5 — Generate

Same two-phase generation as all forges:

Generated Files

Runtime Helpers

Spawn Forge includes three runtime helper classes for evaluating and rolling spawn tables in your game code:

SimpleSpawnContext

A struct that holds current game state values, aligned with your context definitions:

SimpleSpawnRoller

Rolls a spawn table against a context, returning an array of results:

SimpleSpawnEvaluator

Evaluates conditions without performing a roll — useful for checking whether a pool or entry would be active under a given context:

Runtime Data Structures

SimpleSpawnCondition

SimpleSpawnWeightModifier

SimpleSpawnEntry

SimpleSpawnPool

SimpleSpawnTable

Interface Reference — ISimpleSpawnDataSource

Tips

Scaling Forge

Scaling Forge creates profiles that define how enemy numeric properties (HP, ATK, DEF, Speed, etc.) change as a function of level or difficulty. Instead of manually entering stat values for every level, you define a formula and let the math do the work.

Each scaling profile contains rules — one per numeric property you want to scale. A profile is typically paired with an enemy code (e.g., the "GOBLIN_WARRIOR" profile scales HP, ATK, and DEF for goblins), but you can also create shared profiles like "DEFAULT_SCALING" that apply to many enemies.

Open the wizard via Window › Simple Enemy Forge › Scaling Forge Wizard.

Scaling Forge has 3 steps: Setup, Scaling Rules, Generate. There is no Definitions step — Scaling Forge reads its numeric property names directly from the linked Enemy Database.

The 6 Scaling Types

Each scaling rule specifies one of six types that determines how the base value transforms with level:

Formula Examples

Linear

Percentage

Exponential

Step

Step 1 — Setup

Link Enemy Database

Scaling Forge requires exactly one Enemy Database. The wizard reads the database's numeric property names (e.g., HP, ATK, DEF, Speed) and uses them as the target properties for scaling rules. If your Enemy Database has no numeric properties defined, you will need to add some in Enemy Forge first.

Output Configuration

Step 2 — Scaling Rules

The main editing step uses a split-panel layout:

Left Panel — Profile List

• Search — Filter profiles by name or code
• Sort — Sort alphabetically by name or code
• Multi-select — Checkbox selection for bulk operations
• Pagination — Toggle between Show All and paginated view

Right Panel — Profile Editor

Select a profile from the list to edit:

Identity

Name, Code (with Auto toggle), and Description.

Rules

Each profile contains a ReorderableList of rules. Each rule targets one numeric property from the linked Enemy Database:

The remaining fields change based on the selected scaling type:

Formula HelpBox

Below each rule, a HelpBox displays the active equation using the rule's current parameters. This makes it easy to verify your math at a glance:

Slider Preview

At the bottom of the profile editor, an IntSlider lets you pick a preview level. A 5-column table shows the scaling results for every rule in the profile:

This gives you immediate visual feedback on how your scaling rules behave across the level range.

Step 3 — Generate

Same two-phase generation as all forges:

Generated Files

Runtime Helper — SimpleScalingHelper

A static utility class that computes scaled values using the same formulas as the generated databases. Use this when you need to scale values outside of the database's GetScaledValue method.

ComputeScaledValue

ScaleAllNumerics

ScaleEnemy

Using the Generated Database Directly

Runtime Data Structures

SimpleScalingStep

SimpleScalingRule

SimpleScalingProfile

Interface Reference — ISimpleScalingDataSource

Tips

Wave Forge

Wave Forge orchestrates enemies and squads over time. It lets you design wave sequences for tower defense, horde mode, roguelike encounters, and any game mode that spawns enemies in timed waves. Each wave sequence is built from a three-level hierarchy: Sequences > Waves > Entries.

Wave Forge links to your Enemy Database (required) for individual enemy spawns and optionally to a Squad Database for spawning pre-configured squad groups. Open it from Window → Simple Enemy Forge → Wave Forge Wizard.

The wizard has 5 steps: Setup, Definitions, Sequences, Settings, and Generate.

Understanding the Wave Hierarchy

Wave sequences use a three-level nesting structure. A Sequence contains multiple Waves, and each wave contains multiple Entries that define what to spawn and when.

In this example, the "Forest Assault" sequence plays three waves in order. The first wave sends scouts and wolves, the second brings the main force including a full squad group, and the final wave spawns a boss.

Entry Structure

Each entry within a wave is either a single enemy or a squad group, toggled in the wizard. Entries have the following fields:

The IsSquad property returns true if the entry references a squad code, allowing your spawn handler to branch between single-enemy and squad-group spawning logic.

Loop Settings

Each wave sequence has built-in loop settings for endless or escalating game modes:

Loop settings make Wave Forge ideal for endless modes. A sequence with loopAfterLast = true, difficultyScalePerLoop = 1.15, and maxLoops = 0 creates an infinitely escalating challenge.

Step 1 — Setup

Configure the basics and link your databases.

Multiple databases are supported for both types. When duplicates exist across databases, the first database's version wins.

Step 2 — Definitions

Define the dynamic property system for your wave sequences. These properties are attached to sequences, not individual waves or entries.

• Categories — Dropdown properties like Biome, Difficulty Tier, or Game Mode
• Flags — Boolean toggles like Is Tutorial, Has Boss Wave, Is Endless
• Numerics — Number fields like Recommended Level, Total Enemy Count, Estimated Duration
• Texts — String fields like Wave Briefing, Completion Reward Description

This step also provides schema export and import for AI-assisted content creation. Export your definitions as Full JSON, Light JSON, or Markdown, send them to an AI, and import the generated sequences back.

Step 3 — Sequences

Build your wave sequences in a split-panel editor. The left panel shows a paginated list of sequences, and the right panel shows the selected sequence's details.

For each sequence, you define:

• Identity — Name, Code (auto-generated from name), Description
• Waves — An ordered list of waves, each with a name, preDelay, postDelay, and entries
• Entries per wave — Each entry has an enemy/squad toggle, code dropdown, count, spawnDelay, and startTime
• Loop Settings — loopAfterLast, difficultyScalePerLoop, maxLoops
• Dynamic Properties — Values for all categories, flags, numerics, and texts defined in Step 2

Waves and entries use nested ReorderableLists with foldouts, so you can reorder waves by dragging and expand/collapse each one to manage complex sequences.

Step 4 — Settings

Choose output paths for the generated scripts and database asset.

• Scripts Path — Where to write the generated .cs files (enum, database, editor)
• Asset Path — Where to create the .asset database file

Step 5 — Generate

Click Generate to create all output files. Wave Forge uses the same two-phase generation as all other forges:

After generation, your project will contain:

Runtime Helper: SimpleWaveRunner

SimpleWaveRunner is a pure C# event-driven wave runner with no MonoBehaviour dependency. You drive it by calling Update(deltaTime) each frame.

Runner Controls

Runner State

Events

Runtime Data Structures

SimpleWaveSequence

A complete wave sequence with identity, waves, loop settings, and dynamic properties.

SimpleWave

A single wave within a sequence, containing timed spawn entries.

SimpleWaveEntry

A single spawn entry within a wave — either an enemy or a squad.

ISimpleWaveDataSource

Interface implemented by generated wave databases.

Tips

Behavior Forge

Behavior Forge defines condition-based action rules for enemy AI. Instead of hardcoding behavior trees or finite state machines, you author behavior profiles that map conditions to action codes. At runtime, the SimpleBehaviorEvaluator checks conditions against the current game state and returns the best action to take.

Conditions reuse the same SimpleSpawnCondition system from Spawn Forge, checking dynamic numeric properties against thresholds. Actions are user-defined string codes (like FLEE, HEAL, AOE_ATTACK) that your game code interprets.

Open it from Window → Simple Enemy Forge → Behavior Forge Wizard. The wizard has 4 steps: Setup, Definitions, Behavior Rules, and Generate.

How Behavior Profiles Work

A behavior profile is a named collection of rules. Each rule has conditions that check dynamic properties, an action code to trigger, a priority for conflict resolution, and an optional cooldown.

When evaluated, the Goblin Warrior first checks if it should flee (highest priority). If health is fine, it checks whether to call reinforcements. If neither emergency applies, it attacks if in range, or approaches the target as a fallback.

Priority-Based Resolution

When multiple rules match the current conditions, the highest priority wins. Rules are evaluated in priority order (highest first), and the first matching rule is selected as the best action.

This creates a natural decision hierarchy:

• Priority 10+ — Emergency behaviors (flee, heal when critical)
• Priority 7-9 — Tactical behaviors (call reinforcements, use abilities)
• Priority 4-6 — Combat behaviors (melee attack, ranged attack)
• Priority 1-3 — Fallback behaviors (approach target, idle, patrol)

A rule with no conditions always matches, making it an ideal fallback at low priority.

Cooldown System

Each rule has a cooldown field (in seconds) that prevents the same action from triggering repeatedly. After a rule fires, it cannot match again until the cooldown expires. This is tracked per-rule at runtime.

Set cooldown to 0 for actions that should always be available (like basic attacks or movement). Use higher cooldowns for powerful abilities or behaviors that should not spam (like calling reinforcements every 10 seconds).

Step 1 — Setup

Configure the basics for your behavior database.

Unlike Wave Forge or Squad Forge, Behavior Forge does not require linking to an Enemy Database. Behavior profiles are standalone — you assign them to enemies in your own code by matching profile codes to enemy types.

Step 2 — Definitions

Define the dynamic property system for your behavior profiles and the context properties that conditions check against.

Profile Properties

These properties are stored on each behavior profile:

• Categories — Dropdown properties like AI Archetype, Aggression Level
• Flags — Boolean toggles like Uses Ranged, Has Flee Behavior
• Numerics — Number fields like Base Aggro Range, Evaluation Interval
• Texts — String fields like Designer Notes, Behavior Description

Context Properties

Context properties define what the conditions can check against at runtime. These are the numeric values that your game provides in a SimpleSpawnContext when evaluating behavior. Examples include Health Percent, Ally Count, Target Distance, Mana Percent, or any game-state value.

This step also provides schema export and import for AI-assisted content creation.

Step 3 — Behavior Rules

Build your behavior profiles in a split-panel editor. The left panel shows a paginated list of profiles, and the right panel shows the selected profile's rules.

For each profile, you define:

• Identity — Name, Code (auto-generated), Description
• Rules — A ReorderableList of condition-action rules
• Dynamic Properties — Values for categories, flags, numerics, and texts

For each rule within a profile:

• Action Code — A string code your game interprets (e.g., FLEE, HEAL)
• Priority — Integer priority for conflict resolution (higher wins)
• Cooldown — Minimum seconds between triggers
• Conditions — An array of SimpleSpawnCondition checks. Each condition tests a context numeric property against a threshold using a comparison operator (equals, not equals, less than, greater than, etc.). All conditions must pass for the rule to match.

Step 4 — Generate

Click Generate to create all output files using the standard two-phase process.

After generation, your project will contain:

The generated custom editor features a split-panel layout with search, sort, pagination, bulk operations, nested condition editing, and an "Open Behavior Forge Wizard" button for quick access back to the wizard.

Runtime Helper: SimpleBehaviorEvaluator

SimpleBehaviorEvaluator is a static helper class that evaluates behavior profile rules against a SimpleSpawnContext. It reuses SimpleSpawnEvaluator.EvaluateConditions since behavior conditions are the same SimpleSpawnCondition arrays used in Spawn Forge.

Evaluator Methods

Runtime Data Structures

SimpleBehaviorProfile

A named behavior profile containing condition-action rules and dynamic properties.

SimpleBehaviorRule

A single rule that maps conditions to an action code.

ISimpleBehaviorDataSource

Interface implemented by generated behavior databases.

Tips

Faction Forge

Faction Forge defines factions with an N×N relationship matrix that determines how factions interact with each other. Each pair of factions has a stance ranging from Allied to Hostile, enabling your game to query whether two entities should fight, cooperate, or ignore each other.

Each faction also supports dynamic properties (Categories, Flags, Numerics, Texts) for storing custom metadata like faction traits, reputation thresholds, or territorial boundaries.

Open it from Window → Simple Enemy Forge → Faction Forge Wizard. The wizard has 4 steps: Setup, Definitions, Factions, and Generate.

The Relationship Matrix

The relationship matrix is an N×N grid where each cell defines the stance between two factions. The matrix is symmetric — if Humans are Hostile toward Orcs, then Orcs are automatically Hostile toward Humans.

Key properties of the matrix:

• Symmetric — When you set A→B to Hostile, B→A is automatically set to Hostile as well
• Self-relationship is always Allied — A faction is always allied with itself (the diagonal)
• Stored as a flat list — The N×N matrix is stored as a flat List<int> in row-major order for efficient serialization

The matrix grows quadratically with faction count. 4 factions produce a 4×4 matrix (16 cells), 10 factions produce a 10×10 matrix (100 cells). Due to symmetry, only N×(N-1)/2 unique relationships need to be defined.

The 5 Stances

Faction Forge uses the SimpleFactionStance enum with 5 possible stances, stored as integer values from -2 to 2:

The numeric values allow easy comparison. Stances less than 0 are negative, 0 is neutral, and greater than 0 are positive. This makes range checks straightforward in game code.

Step 1 — Setup

Configure the basics and optionally link enemy databases.

Step 2 — Definitions

Define the dynamic property system for your factions. These properties are attached to each faction definition, letting you store custom metadata.

• Categories — Dropdown properties like Government Type, Alignment, Territory Size
• Flags — Boolean toggles like Is Playable, Has Territory, Is Hidden
• Numerics — Number fields like Reputation Threshold, Military Strength, Population
• Texts — String fields like Lore, Capital City, Leader Name

This step also provides schema export and import for AI-assisted content creation. The schema includes the relationship matrix, which round-trips through JSON import with full symmetric validation.

Step 3 — Factions

Build your factions in a split-panel editor. The left panel shows the faction list, and the right panel shows the selected faction's details.

Identity

Each faction has a Name, Code (auto-generated from name), and Description.

Dynamic Properties

All four property sections (Categories, Flags, Numerics, Texts) are always visible with values for each property defined in Step 2.

Relationships

The relationships section shows a stance dropdown for every other faction in the database. When you change A's stance toward B, B's stance toward A is automatically updated to match (symmetric write).

Adding or removing a faction automatically expands or shrinks the relationship matrix for all existing factions.

Step 4 — Generate

Click Generate to create all output files using the standard two-phase process.

After generation, your project will contain:

The generated custom editor features a split-panel layout with search, sort, pagination, bulk operations, dynamic property editing, and per-faction relationship editing with symmetric matrix writes.

Runtime Helper: SimpleFactionHelper

SimpleFactionHelper is a static helper class that provides convenience methods for querying faction relationships beyond what ISimpleFactionDataSource offers directly.

Using the Interface Directly

Using SimpleFactionHelper

Helper Methods

Runtime Data Structures

SimpleFactionStance (Enum)

The stance enum with integer values for easy comparison.

SimpleFactionDefinition

A single faction with identity, color, and dynamic properties.

Relationship Matrix

The relationship matrix is stored as a flat List<int> in row-major order. For N factions, the matrix has N×N entries. To get the stance from faction index A to faction index B:

In practice, you should use the ISimpleFactionDataSource interface methods rather than indexing the matrix directly.

ISimpleFactionDataSource

Interface implemented by generated faction databases.

Tips

AI-Powered Content Generation

All 7 wizards support schema export for AI content generation. Export your property definitions, paste them into ChatGPT or Claude, and import hundreds of enemies, squads, spawn tables, scaling profiles, wave sequences, behavior profiles, or factions in one click.

The Workflow

Three Export Modes

Most wizards offer 3 export buttons. Enemy Forge and Scaling Forge offer 2 (Full JSON + Markdown only — no Light JSON):

What the Schema Contains

Exported schemas are comprehensive and designed for AI consumption:

AI Instruction Sections (Enemy Forge)

The Enemy Forge schema includes the following AI instruction sections. Other forges follow the same pattern with content adapted to their domain:

• propertyTypesOverview — Conceptual explanation of Categories, Flags, Numerics, Texts with analogies
• questionsToAskUser — 5-6 step question workflow the AI should follow before generating
• whatYouCanDo / whatYouCannotDo — Clear boundaries for AI generation
• categoryGuidance, flagGuidance, numericGuidance, textGuidance — Per-property usage hints derived from your definitions
• enemyBalanceGuidance — Stat scaling, rank budgets, naming conventions for enemies
• simpleEnemyForgeEcosystem — Explains all 7 forges and how enemies feed into squads, spawn tables, waves, etc.
• jsonFormatExample — Dynamic example using your actual current definitions (generated from your schema)
• aiSpecificGuidance — 6-phase workflow (Ask, Study, Plan, Generate, Validate, Iterate)

Ecosystem-Aware Generation

The schema tells AI about all 7 forges so it generates content with the full pipeline in mind:

The AI instructions prompt it to ask the user which systems they plan to use before generating, so it creates the right mix of enemies.

Import Validation

When importing AI-generated JSON, the system validates everything:

• Code uniqueness — Duplicate codes are skipped with a reason
• Enemy code references — Squad, Spawn, and Wave imports validate that referenced enemy codes exist in the linked database
• Property mapping — Categories, flags, and numerics are matched by name (case-insensitive)
• Type validation — Numeric values checked against constraints, category indices validated against entry lists
• Smart defaults — Integer detection from name keywords (level, count, tier, rank, HP)
• 3-choice dialog — For definitions import: Replace All, Merge (keep existing), or Cancel

After import, a result popup shows: total in file, successfully imported, skipped with reasons, and any warnings.

Schema Export per Wizard

Tips for Best Results

Genre Templates

Simple Enemy Forge includes 6 genre templates that pre-populate your property definitions (categories, flags, numerics, texts) and example enemies in a single click. Templates are applied in Enemy Forge Step 1 (Setup) and serve as starting points that you can freely modify to match your game.

Template Overview

Generic RPG

Standard RPG enemy system with types, ranks, elements, combat stats, and reward values. Works for most traditional RPGs, JRPGs, action RPGs, and MMOs.

Categories (4)

• Enemy Type — Beast, Humanoid, Undead, Demon, Dragon, Elemental, Construct, Plant
• Rank — Minion, Normal, Elite, Mini-Boss, Boss, Raid Boss
• Element — None, Fire, Ice, Lightning, Earth, Wind, Water, Light, Dark
• Weakness (multi-select) — None, Fire, Ice, Lightning, Earth, Wind, Water, Light, Dark

Flags (6)

• Is Boss, Is Flying, Is Undead, Respawns, Is Aggressive, Can Be Stunned

Numerics (10)

• HP, MP, Attack, Defense, Magic Attack, Magic Defense, Speed, Level, EXP Reward, Gold Reward

Texts (2)

• Bestiary Entry (4 lines), Combat Notes (2 lines)

Example Enemies

• Forest Wolf — Beast / Normal / No element, pack hunter with low stats
• Skeleton Knight — Undead / Normal / Dark element, armored melee fighter
• Ancient Dragon — Dragon / Boss / Fire element, multi-phase flight boss

Soulslike

Soulslike enemy system with poise, stagger thresholds, damage types, weakness multipliers, and multi-phase boss support. Designed for punishing, pattern-based combat.

Categories (4)

• Enemy Class — Hollow, Knight, Beast, Aberration, Demigod, Dragon, Spirit, Automaton
• Size — Small, Medium, Large, Huge, Colossal
• Damage Type (multi-select) — Physical, Magic, Fire, Lightning, Holy, Frost, Poison, Bleed
• Weakness (multi-select) — None, Physical, Magic, Fire, Lightning, Holy, Frost, Bleed

Flags (5)

• Is Boss, Is Parryable, Is Backstabbable, Has Phases, Respawns On Rest

Numerics (15)

• HP, FP, Physical ATK, Physical DEF, Magic DEF, Fire DEF, Lightning DEF, Holy DEF, Poise, Stagger Threshold, Phase Count, Souls Reward, Bleed Resist, Poison Resist, Frost Resist

Texts (3)

• Lore (4 lines), Combat Strategy (3 lines), Location (1 line)

Example Enemies

• Hollow Soldier — Hollow / Medium, basic parryable patrol enemy
• Abyssal Guardian — Knight / Large, multi-phase boss corrupted by the Abyss with high poise
• Crystal Lizard — Beast / Small, timid creature that flees on sight and drops upgrade materials

Survival / Horror

Survival horror enemy system with detection ranges, aggro behavior, sensory systems, infection/contamination mechanics, and fear factor. For horror, zombie, and survival games.

Categories (5)

• Creature Type — Zombie, Mutant, Parasite, Ghost, Stalker, Swarm, Abomination, Human
• Threat Level — Nuisance, Moderate, Dangerous, Lethal, Unkillable
• Movement Type — Shamble, Walk, Run, Crawl, Lunge, Teleport, Float
• Damage Type (multi-select) — Blunt, Slash, Bite, Grab, Acid, Psychic, Explosion, Infection
• Vulnerability (multi-select) — None, Fire, Headshot, Light, Sound, Electricity, Explosives, Melee

Flags (8)

• Can Infect, Reacts To Sound, Reacts To Light, Can Open Doors, Can Climb, Plays Dead, Alerts Others, Drops Loot

Numerics (12)

• HP, Damage (range), Move Speed, Detection Range, Aggro Range, Sound Sensitivity, Infection Chance, Fear Factor, Headshot Multiplier, Attack Cooldown, Spawn Weight, Corpse Linger Time

Texts (2)

• Bestiary Entry (4 lines), Survival Tips (3 lines)

Example Enemies

• Shambler — Zombie / Nuisance, slow rotting corpse attracted to noise
• Stalker — Stalker / Dangerous, evolved infected with heightened senses and terrifying speed
• Bloater — Mutant / Lethal, massively swollen infected that explodes on death releasing toxic spores

Tower Defense

Tower defense enemy system with movement types, armor categories, resistances, special abilities, and wave/economy values. For TD, strategy, and base defense games.

Categories (4)

• Unit Type — Infantry, Armored, Fast, Flying, Burrowing, Boss, Swarm, Healer
• Armor Type — Unarmored, Light, Medium, Heavy, Fortified, Magic
• Size — Tiny, Small, Medium, Large, Massive
• Resistance (multi-select) — None, Fire, Ice, Lightning, Poison, Physical

Flags (6)

• Is Flying, Is Burrowing, Is Stealth, Splits On Death, Heals Nearby, Buffs Nearby

Numerics (10)

• HP, Armor, Move Speed, Bounty, Lives Cost, Spawn Count, Spawn Interval, Split Count, Heal Rate, Wave Value

Texts (1)

• Description (2 lines)

Example Enemies

• Goblin Runner — Fast / Unarmored, cheap swarm unit in large groups
• Iron Golem — Armored / Fortified, slow high-HP tank that absorbs tower damage
• Wyvern — Flying / Light, aerial unit that bypasses ground defenses

Sci-Fi / Shooter

Sci-fi shooter enemy system with armor types, shield systems, weapon loadouts, weak points, and combat AI profiles. For FPS, TPS, and sci-fi action games.

Categories (5)

• Enemy Class — Grunt, Soldier, Heavy, Sniper, Engineer, Drone, Mech, Elite
• Faction — Raiders, Military, Alien, Robot, Mutant, Pirate, Corporate
• Armor Type — None, Light Suit, Medium Plating, Heavy Plating, Energy Shield, Composite
• Weapon Type (multi-select) — Melee, Pistol, Rifle, Shotgun, Sniper, Launcher, Energy, Flamethrower
• Weak Point (multi-select) — None, Head, Back, Legs, Power Core, Fuel Tank, Antenna, Eye

Flags (5)

• Has Shields, Uses Cover, Can Flank, Throws Grenades, Calls Reinforcements

Numerics (14)

• HP, Shield HP, Shield Regen Rate, Armor Rating, Damage Per Shot (range), Fire Rate, Accuracy, Detection Range, Move Speed, Weak Point Multiplier, XP Reward, Threat Level, Grenade Cooldown, Shield Regen Delay

Texts (2)

• Intel Report (3 lines), Tactical Notes (2 lines)

Example Enemies

• Raider Grunt — Grunt / Raiders, poorly equipped scavenger dangerous in numbers
• Corporate Enforcer — Soldier / Corporate, well-trained operative with energy shields and tactical awareness
• Heavy Mech Unit — Mech / Military, bipedal combat mech with missile launchers and heavy plating

RTS / Strategy

RTS enemy/unit system with unit classes, armor types, attack categories, build costs, population values, and tactical properties. For RTS, 4X, and tactical strategy games.

Categories (6)

• Unit Class — Infantry, Cavalry, Ranged, Siege, Support, Hero, Naval, Air
• Armor Class — Unarmored, Light, Medium, Heavy, Fortified, Divine
• Attack Type — Normal, Pierce, Siege, Magic, Chaos, Hero
• Faction — Human, Orc, Elf, Undead, Dwarf, Demon, Neutral
• Tier — Tier 1, Tier 2, Tier 3, Tier 4, Ultimate
• Ability (multi-select) — None, Heal, Buff, Debuff, AoE, Summon, Stealth, Charge

Flags (8)

• Is Ranged, Is Flying, Is Siege, Is Hero, Can Harvest, Can Build, Can Heal, Has Aura

Numerics (16)

• HP, Mana, Attack Damage (range), Armor, Attack Speed, Attack Range, Move Speed, Sight Range, Gold Cost, Lumber Cost, Supply Cost, Build Time, XP Bounty, Gold Bounty (range), HP Regen, Mana Regen

Texts (2)

• Unit Description (2 lines), Tactical Role (2 lines)

Example Enemies

• Footman — Infantry / Human / Tier 1, versatile frontline fighter
• Elven Archer — Ranged / Elf / Tier 1, long-range pierce damage dealer
• Orcish Warlord — Hero / Orc / Tier 3, powerful hero with War Cry and Command Aura
• Catapult — Siege / Human / Tier 3, long-range siege weapon with devastating AoE damage

Generated Custom Editors

When you generate a database after applying a template, the generated custom Inspector editor automatically adapts to your property definitions:

• Category dropdowns — Each category becomes a popup or multi-select field in the Inspector
• Flag toggles — Each flag becomes a full-width ToggleLeft, one per row
• Numeric fields — Each numeric becomes an IntField/FloatField or a min-max range slider
• Text areas — Each text becomes a scrollable TextArea with the configured line count
• Split panel layout — List on the left, detail view on the right with search, sort, filter, and pagination

The generated editor reflects your template exactly. If you chose Generic RPG, you get Enemy Type and Rank dropdowns, Is Boss and Is Flying toggles, HP/MP/Attack fields, and Bestiary Entry text areas. If you chose RTS, you get Unit Class, Armor Class, Gold Cost, Lumber Cost, Build Time fields instead.

Tips

Simple Attribute Forge Integration

Simple Enemy Forge has optional integration with Simple Attribute Forge (SAF), sold separately. When both packages are installed in the same project, the Enemy Forge automatically detects SAF and unlocks modifier references on enemies. No manual configuration is required — just import both packages and the features appear.

Features Enabled by SAF

When SAF is detected, one additional capability appears in the Enemy Forge wizard and generated editors:

Where SAF Features Appear

Detection Lifecycle

SAF detection is fully automatic and bidirectional. An [InitializeOnLoad] detector runs every time Unity performs a domain reload (after compilation, script changes, or package imports). It uses reflection only — no hard assembly references — so it compiles cleanly whether SAF is present or not.

Installing SAF

Removing SAF

The SAFBridge Pattern

Simple Enemy Forge never has a hard assembly reference to Simple Attribute Forge. Instead, all editor code accesses SAF through a static bridge class:

This pattern means:

• No using SimpleForgeFramework; statements in the main editor code
• No assembly definition references to SAF assemblies
• No conditional assemblies that might fail to recompile
• Clean compilation in both directions (install and remove)

Runtime vs. Editor Behavior

SAF integration is split into two layers: unconditional runtime types that always compile, and conditional editor code that only activates when SAF is present.

Always Compiled (Unconditional)

The SimpleEnemyDefinition struct in the runtime namespace always includes:

Because modifiers are stored as ScriptableObject[] (not a SAF-specific type), the generated database class always compiles — the field exists whether SAF is installed or not. This is what makes the install/remove cycle error-free.

Conditional (Editor Only)

The following editor features are gated behind SAFBridge.IsAvailable runtime checks and only activate when SAF is installed:

• The “Simple Attribute Forge Integration” section in Enemy Forge Step 1
• Modifier ReorderableList UI in Enemy Forge Step 3
• Modifier data sections in schema export (Full JSON, Light JSON, Markdown)
• Modifier ObjectField sections in generated custom editors (uses runtime Type.GetType() for ObjectField type filtering — auto-adapts when SAF is installed/uninstalled without regeneration)

When SAF is removed, these sections simply disappear. The wizard reverts to its base feature set with no visible errors or broken UI.

Generated Database Behavior

Understanding how generated databases behave across SAF install/remove cycles:

Generated With SAF Installed

When you generate an Enemy Database while SAF is available and modifiers are assigned:

• Each enemy’s modifiers array holds references to modifier .asset files
• The generated custom editor shows modifier ObjectFields filtered to SAF modifier assets

After Removing SAF

• The generated database still compiles — ScriptableObject[] is an unconditional Unity type
• Existing references are preserved in the .asset file — Unity serializes ScriptableObject references regardless of the asset’s type
• The custom editor hides the Modifiers section — you won’t see modifiers in the Inspector, but the data is still there in the serialized asset
• Modifier references become null if the modifier .asset files were removed along with SAF

Regenerating Without SAF

If you open the Enemy Forge wizard and regenerate without SAF installed:

• The wizard has no modifier UI, so no modifiers can be assigned
• Generated enemies will have empty modifiers arrays
• The previous .asset data is overwritten with the new (empty) data
• If you want to preserve modifier data, do not regenerate after removing SAF

Troubleshooting

SAF features not appearing after import

• Check installation — Ensure Simple Attribute Forge is imported in the same project (not a different project or a Package Manager reference to a missing path)
• Check the define symbol — Open Player Settings → Scripting Define Symbols and verify SIMPLE_ATTRIBUTE_FORGE is listed. If not, the detector may not have run yet.
• Force a recompile — Try Assets → Reimport All or make a trivial edit to any script to trigger compilation and a domain reload.
• Check the Console — If SAF itself has compilation errors, the detector cannot find its types. Fix any SAF errors first.

SAF features not disappearing after removal

• Check the define symbol — If SIMPLE_ATTRIBUTE_FORGE is still in Scripting Define Symbols after deleting SAF, remove it manually and recompile.
• Force a domain reload — The detector runs on domain reload. If Unity didn’t trigger one, reimport a script or restart Unity.

Modifier references lost after regeneration

• Modifier fields store Unity object references to .asset files. These references survive regeneration as long as the modifier assets still exist at the same paths.
• If modifier assets were moved or deleted, re-assign them in the generated Inspector editor.
• Modifier references cannot be set via JSON import — they must be assigned manually via drag-and-drop in the wizard or the generated editor.

Compilation errors after removing SAF

This should never happen if Simple Enemy Forge is the only package using SAF. If you see errors:

• Check that SIMPLE_ATTRIBUTE_FORGE was removed from Scripting Define Symbols
• Check for other packages or custom scripts that may have hard references to SAF types
• Ensure you deleted the entire SAF package, not just parts of it (partial deletion can leave broken assembly definitions)

Simple Item Forge Integration

Simple Enemy Forge has optional integration with Simple Item Forge (SIF), sold separately. When both packages are installed in the same project, the Enemy Forge automatically detects SIF and unlocks loot table linking on enemies. No manual configuration is required — just import both packages and the features appear.

Features Enabled by SIF

When SIF is detected, two additional fields appear on each enemy:

Where SIF Features Appear

Detection Lifecycle

SIF detection follows the same automatic pattern as SAF detection. An [InitializeOnLoad] detector runs on every domain reload and uses reflection only — no hard assembly references.

Installing SIF

Removing SIF

The SIFBridge Pattern

Simple Enemy Forge never has a hard assembly reference to Simple Item Forge. Instead, all editor code accesses SIF through a static bridge class:

This pattern means:

• No using SimpleItemForge; statements in the main editor code
• No assembly definition references to SIF assemblies
• No conditional assemblies that might fail to recompile
• Clean compilation in both directions (install and remove)

Runtime Fields

The SimpleEnemyDefinition struct always includes these loot-related fields, regardless of whether SIF is installed:

Because both fields use plain Unity types (string and ScriptableObject), the generated database class always compiles regardless of whether SIF is present. This is what makes the install/remove cycle error-free.

Generated Database Behavior

Understanding how generated databases behave across SIF install/remove cycles:

Generated With SIF Installed

When you generate an Enemy Database while SIF is available and loot tables are assigned:

• Each enemy’s lootTableCode is set to the selected code string
• Each enemy’s lootTable holds a reference to the SIF loot table .asset file
• The generated custom editor shows a dropdown for code selection and an ObjectField for direct reference

After Removing SIF

• The generated database still compiles — both fields are plain Unity types
• Loot table codes are preserved — strings survive regardless of SIF status
• Loot table asset references are preserved if the .asset files still exist
• The custom editor hides loot table UI — the dropdown and ObjectField disappear, but the data remains in the serialized asset
• Asset references become null if the loot table .asset files were removed along with SIF

Regenerating Without SIF

If you open the Enemy Forge wizard and regenerate without SIF installed:

• The wizard has no loot table UI, so no loot table codes or references can be assigned
• Generated enemies will have empty lootTableCode and null lootTable
• The previous .asset data is overwritten
• If you want to preserve loot table data, do not regenerate after removing SIF

Troubleshooting

SIF features not appearing after import

• Check installation — Ensure Simple Item Forge is imported in the same project (not a different project or a Package Manager reference to a missing path)
• Check the define symbol — Open Player Settings → Scripting Define Symbols and verify SIMPLE_ITEM_FORGE is listed. If not, the detector may not have run yet.
• Force a recompile — Try Assets → Reimport All or make a trivial edit to any script to trigger compilation and a domain reload.
• Check the Console — If SIF itself has compilation errors, the detector cannot find its types. Fix any SIF errors first.

Loot table dropdown is empty

• Assign the loot database — In Enemy Forge Step 1, the SIF Integration section has an ObjectField for your loot database. Assign a generated SIF loot database asset. The dropdown in Step 3 is populated from this linked database.
• Generate the SIF loot database first — The SIF Loot Forge wizard must have been used to generate at least one loot database with loot table entries before the dropdown can be populated.

SIF features not disappearing after removal

• Check the define symbol — If SIMPLE_ITEM_FORGE is still in Scripting Define Symbols after deleting SIF, remove it manually and recompile.
• Force a domain reload — The detector runs on domain reload. If Unity didn’t trigger one, reimport a script or restart Unity.

Compilation errors after removing SIF

This should never happen if Simple Enemy Forge is the only package using SIF. If you see errors:

• Check that SIMPLE_ITEM_FORGE was removed from Scripting Define Symbols
• Check for other packages or custom scripts that may have hard references to SIF types
• Ensure you deleted the entire SIF package, not just parts of it (partial deletion can leave broken assembly definitions)

Demos Overview

Simple Enemy Forge ships with one interactive demo — the Bestiary Demo, a 7-tab runtime data browser that showcases all forge outputs in a single scene. It exercises every generated database type and all 7 runtime helpers, giving you a hands-on preview of what your data looks like at runtime.

Bestiary Demo

The Bestiary Demo is generated via Window › Simple Enemy Forge › Generate Bestiary Demo (menu priority 201). It creates a complete runtime scene with a full-screen Canvas UI using a Black + Crimson Red (#C43A31) color scheme, matching Simple Enemy Forge's documentation theme.

The demo mirrors the pattern established by Simple Item Forge's ARPG Demo (ARPGDemoGenerator.cs + ARPGDemo.cs), adapted for SEF's 7 forges and runtime helpers.

Setup

Getting the Bestiary Demo running takes 3 steps:

The 7 Tabs

Each tab corresponds to one of the 7 forges and demonstrates the runtime API for that forge:

Key Features

Dynamic Context Controls

The Spawn and Behavior tabs build context controls dynamically from your database metadata. For each context category, a dropdown is generated. For each context flag, a toggle is generated. For each context numeric, a slider is generated. These controls map directly to SimpleSpawnContext values used by the runtime helpers.

Layout

The demo targets 1920x1080 resolution using a CanvasScaler with ScaleWithScreenSize mode. The UI uses split panels with a 32% list / 68% detail ratio, matching the split-panel pattern used in the generated custom editors.

Navigation

A Back button in the top-left corner destroys the demo canvas and returns to the scene's default state. There is no persistent inventory bar (unlike SIF's ARPG Demo) since SEF is a data browsing tool, not an inventory simulation.

Runtime Helpers in Action

The demo exercises all 6 runtime helper classes:

• SimpleSpawnRoller — powers the Spawn tab's ROLL button
• SimpleSpawnContext — built from UI controls for Spawn and Behavior tabs
• SimpleSpawnEvaluator — used internally by the roller and behavior evaluator
• SimpleScalingHelper — powers the Scaling tab's live preview
• SimpleWaveRunner — drives the Waves tab's simulation (called in Update())
• SimpleBehaviorEvaluator — powers the Behavior tab's EVALUATE button
• SimpleFactionHelper — used by the Factions tab for relationship queries

Technical Reference

The Bestiary Demo consists of 2 files:

Overview

All runtime types live in the SimpleEnemyForge namespace. Each forge wizard generates a database ScriptableObject that implements a corresponding interface. You can access data either by casting directly to the generated type, or by using the interface for generic code.

Two access patterns are available for all databases:

Enemy Database

SimpleEnemyDefinition Struct

Defines a single enemy with all its properties. Uses dynamic property arrays that correspond to the property definitions stored in the database.

Convenience Accessors

SimpleEnemyDefinition provides safe accessor methods that return defaults for out-of-range indices:

ISimpleEnemyDataSource Interface

Enemy Access

Property Definitions

Dynamic Filtering

Code Example

Squad Database

SimpleSquadSlot Struct

SimpleSquadGroup Struct

ISimpleSquadDataSource Interface

Code Example

Spawn Database

Data Hierarchy

Spawn tables use a 4-level hierarchy: Table › Pool › Entry › Condition.

SimpleSpawnTable Struct

SimpleSpawnPool Struct

SimpleSpawnEntry Struct

SimpleSpawnCondition Struct

Condition Enums

SimpleSpawnWeightModifier Struct

ISimpleSpawnDataSource Interface

Scaling Database

SimpleScalingType Enum

SimpleScalingStep Struct

SimpleScalingRule Struct

SimpleScalingProfile Struct

ISimpleScalingDataSource Interface

Wave Database

Data Hierarchy

Wave data uses a 3-level hierarchy: Sequence › Wave › Entry.

SimpleWaveEntry Struct

SimpleWave Struct

SimpleWaveSequence Struct

ISimpleWaveDataSource Interface

Behavior Database

SimpleBehaviorRule Struct

SimpleBehaviorProfile Struct

ISimpleBehaviorDataSource Interface

Faction Database

SimpleFactionStance Enum

SimpleFactionDefinition Struct

ISimpleFactionDataSource Interface

Faction Access

Relationship Queries

Metadata Access

Runtime Helpers

SEF includes 7 static/instance helper classes for common runtime operations. These are ready to use out of the box — no code generation needed.

1. SimpleSpawnRoller

Rolls spawn tables using weighted random selection. Evaluates pool conditions, computes effective weights with modifiers, and performs with-replacement random selection.

SpawnRollResult struct fields: enemyCode, squadCode, IsSquad, sourcePoolName, poolIndex, entryIndex.

2. SimpleSpawnContext

Holds current game state values for evaluating spawn and behavior conditions. Includes a fluent builder pattern for easy construction.

3. SimpleSpawnEvaluator

Static building blocks for spawn condition evaluation and weight computation. Used internally by SimpleSpawnRoller and available for custom spawn logic.

4. SimpleScalingHelper

Static utility for computing scaled values from scaling rules and profiles.

5. SimpleWaveRunner

Pure C# event-driven wave runner. Not a MonoBehaviour — you call Update(deltaTime) from your own game loop. Drives a state machine through PreDelay, Spawning, PostDelay phases with loop support.

Events

Control Methods

Read-Only State

6. SimpleBehaviorEvaluator

Static methods for evaluating behavior profile rules against a spawn context. Uses the same condition system as spawn tables.

7. SimpleFactionHelper

Static convenience methods for faction relationship queries beyond what ISimpleFactionDataSource provides directly.

Namespace Reference

All runtime types in the SimpleEnemyForge namespace:

Troubleshooting

Solutions for common issues you may encounter when using Simple Enemy Forge.

Generation Issues

Database asset not created after generation

Simple Enemy Forge uses a two-phase generation process. The first phase writes C# scripts, triggers AssetDatabase.Refresh(), and waits for Unity's domain reload. The second phase (triggered by [InitializeOnLoad]) creates the asset from a temporary JSON file.

• Wait for compilation — After clicking Generate, Unity's progress bar should show "Compiling Scripts". Wait for it to finish completely.
• Check the Console — Look for errors with the [Simple Enemy Forge] prefix. If the first phase fails, the second phase never runs.
• Check SessionState — The second phase uses SessionState flags (e.g., SimpleEnemyForge_WaitingForCompilation). If Unity crashes during compilation, the flag may be left in a stale state. Restarting Unity clears SessionState.
• Check the output folder — Verify the target folder path in Step 1 (Setup) exists and is writable.

Compilation errors after generation

• Duplicate type names — If you generate two databases with the same Class Prefix, you'll get duplicate type errors. Use unique prefixes for each database.
• Missing namespace — Generated code uses using SimpleEnemyForge;. Make sure the Simple Enemy Forge Runtime assembly definition is accessible from your generated code's location.
• Regenerate — If files got corrupted, delete the generated {Prefix}Type.cs, {Prefix}Database.cs, and {Prefix}DatabaseEditor.cs files, then generate again from the wizard.

Custom editor not showing in Inspector

• Check the Editor file — Ensure {Prefix}DatabaseEditor.cs exists in the same folder as the database asset (or in an Editor folder).
• Reimport — Right-click the editor script and select Reimport to force Unity to pick up the [CustomEditor] attribute.
• Lock/unlock the Inspector — Sometimes toggling the Inspector's lock button forces a refresh of the custom editor.

Schema Import Issues

Import says "0 items imported"

• Check JSON format — The import expects a specific JSON structure with top-level arrays matching the forge type (e.g., "enemies" for Enemy Forge, "squads" for Squad Forge). AI-generated JSON sometimes uses different field names.
• Validate required fields — Every item needs at minimum a code and name field. Items missing these are skipped.
• Check the result popup — The import shows a popup with imported count, skipped count, and any errors/warnings. Read the messages for specific issues.

AI-generated JSON won't import

• Use Full JSON export — When exporting a schema for AI, use "Full JSON" mode. This includes the complete JSON format example with field names and types that the AI should replicate exactly.
• Check the definitions section — The JSON format example includes a "definitions" section that tells the AI which property names to use. If definitions are missing, the AI may guess wrong field names (e.g., "name" instead of "label" for categories, "options" instead of "entries").
• Strip markdown — If the AI wrapped the JSON in a code block (```json ... ```), remove the markdown markers before importing.
• Validate JSON syntax — Use a JSON validator to check for syntax errors (missing commas, unmatched brackets, trailing commas).

Values not mapping correctly

• Category values — Categories use integer indices (0-based) into the entry list, not the entry strings themselves. If the AI provides string values, they won't map. The schema instructions tell the AI to use indices.
• Flag values — Flags must be true/false, not 0/1 or "yes"/"no".
• 3-choice dialog — When importing, a dialog asks whether to Replace All, Cancel, or Keep Existing (for definitions) / Add to Existing (for data). Choose the appropriate option for your use case.

Wizard Issues

Can't proceed to next step

• Check validation — Each step validates required fields before allowing navigation. Common blockers: empty Class Prefix, duplicate codes, no output folder selected.
• Class Prefix rules — Must start with a letter, contain only letters and digits, and be a valid C# identifier. No spaces, underscores, or special characters.

Linked database shows 0 enemies

• Check interface — Dependent wizards (Squad, Spawn, Scaling, Wave) require an enemy database that implements ISimpleEnemyDataSource. If you manually created a ScriptableObject without implementing the interface, it won't be detected.
• Regenerate enemy DB first — The enemy database must be fully generated (including the .asset file) before linking it to dependent wizards.
• Multi-DB merging — You can assign multiple enemy databases. Duplicate codes are resolved with first-DB-wins: the first database's version takes priority.

Data lost after domain reload

• This is expected — Wizard data is stored in memory (EditorWindow state) and survives most domain reloads via Unity's serialization. However, some complex data structures may not survive. Always generate before closing Unity.
• Use templates — If you frequently lose configuration, save your setup as a template file via the schema export feature. You can re-import it later.

Custom Editor Issues

Inspector shows "Element 0", "Element 1" instead of custom editor

• Missing editor file — The generated {Prefix}DatabaseEditor.cs must be in an Editor folder or an Editor assembly. If it was accidentally deleted, regenerate from the wizard.
• Assembly mismatch — If you moved the database script outside the Simple Enemy Forge assembly, the generated editor may not find the type. Keep generated files together.

Editor performance slow with many entries

• Use pagination — The generated editor includes pagination. Toggle off "Show All" and set a reasonable page size (20-50 items). Pagination is also available in wizard builder steps.
• Collapse foldouts — Keep foldouts collapsed for entries you're not actively editing. Expanded entries render all property fields, which adds up.

Browse button not showing enemy/squad references

• Link databases — The generated editor's browse functionality depends on finding the referenced database assets. Make sure the databases are in the same project and haven't been renamed or moved.

SAF Integration

For SAF-specific troubleshooting (detection issues, modifier references, safe round-trip), see the dedicated SAF Integration Troubleshooting section.

SIF Integration

For SIF-specific troubleshooting (loot table linking, detection lifecycle, safe round-trip), see the dedicated SIF Integration Troubleshooting section.

General Tips

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

The Forge Ecosystem

Seven interconnected wizards, each generating a complete database system:

The Dynamic Property System

Instead of hardcoded fields, SEF uses four dynamic property types that you define in Step 2 (Definitions) of each wizard:

What Gets Generated

Each forge generates 3 C# files and 1 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.

Full details →

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.

Full details →

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