DEV Community: Roman Kalinchuk

How to Build Readable Unit Formations in Unity (Procedural Layouts + Runtime Behaviours)

Roman Kalinchuk — Mon, 14 Sep 2026 08:31:11 +0000

How to Build Readable Unit Formations in Unity with Procedural Layouts and Runtime Behaviours

In an RTS, tactics game or tower defense project, moving a group of units is more difficult than moving a single character.

A useful formation system needs to solve several problems at once:

generate positions for the whole group;
assign units to those positions;
keep the formation readable while it moves;
support different layouts for different gameplay situations;
react to targets, paths and obstacles;
avoid rebuilding expensive data every frame;
make the result easy to preview and debug.

A common mistake is to treat every unit as an independent agent. That approach can work for small groups, but it becomes harder to control as the number of units grows. A formation gives the group a shared structure while still allowing individual units to move toward their assigned positions.

Start with a formation anchor

The first useful abstraction is a formation anchor.

The anchor represents the group as a whole. It can contain:

a position;
a rotation or facing direction;
a destination;
a list of local formation positions;
the current group state.

The units do not need to calculate the entire formation independently. Instead, the system generates local slots around the anchor, and each unit receives a target slot.

The local slot positions can then be transformed into world space using the anchor's position and rotation.

Conceptually, the process looks like this:

Formation layout → Local slots → World-space targets → Unit movement

This separation makes the system easier to extend. You can change the layout without rewriting the movement code, or change the movement behaviour without changing how the slots are generated.

Procedural formation layouts

A formation does not have to be a hardcoded list of transforms. It can be generated from a small set of parameters such as:

unit count;
spacing;
width;
depth;
radius;
direction;
custom seed;
target position.

For example, a simple grid formation can be generated from rows and columns:

using UnityEngine;

public static class FormationLayout
{
    public static Vector3[] CreateGrid(int unitCount, int columns, float spacing)
    {
        Vector3[] slots = new Vector3[unitCount];

        if (columns <= 0)
        {
            columns = 1;
        }

        for (int i = 0; i < unitCount; i++)
        {
            int row = i / columns;
            int column = i % columns;

            float x = (column - (columns - 1) * 0.5f) * spacing;
            float z = -row * spacing;

            slots[i] = new Vector3(x, 0f, z);
        }

        return slots;
    }
}

The result is a set of positions relative to the formation anchor. The same movement system can use those positions for an RTS squad, a tactical group or a tower defense wave.

Different layouts serve different gameplay roles

A grid is useful for compact groups, but different gameplay situations benefit from different shapes.

Examples include:

line formations for advancing units;
wedges for attacking or moving through space;
walls for defensive positioning;
circles and rings for surrounding a target;
arcs for readable front-facing groups;
columns for narrow paths;
spirals and radial patterns for visual effects;
custom positions for designed encounters.

The important design decision is to keep the layout independent from unit movement. A unit should not need to know whether its target came from a grid, a wedge or a ring.

Assign units to slots predictably

Once the slots are generated, the system needs to assign units to them.

A simple approach is to assign units by index. This is easy to implement, but it can create unnecessary movement when the formation changes or units are selected in a different order.

More advanced assignment can consider:

the unit's current position;
the distance to each slot;
the unit's role;
the previous slot assignment;
the direction of movement;
whether the unit is already close to a suitable slot.

Stable assignment is important. If units constantly exchange slots, the group can look disorganized even when the target positions are correct.

Move units toward formation targets

Each unit can use its assigned world-space slot as a movement target.

A basic movement loop might look like this:

using UnityEngine;

public class FormationUnit : MonoBehaviour
{
    [SerializeField] private float moveSpeed = 4f;
    [SerializeField] private float turnSpeed = 8f;

    private Vector3 targetPosition;

    public void SetFormationTarget(Vector3 position)
    {
        targetPosition = position;
    }

    private void Update()
    {
        Vector3 offset = targetPosition - transform.position;
        offset.y = 0f;

        if (offset.sqrMagnitude < 0.01f)
        {
            return;
        }

        Vector3 direction = offset.normalized;
        transform.position += direction * moveSpeed * Time.deltaTime;

        Quaternion targetRotation = Quaternion.LookRotation(direction);
        transform.rotation = Quaternion.Slerp(
            transform.rotation,
            targetRotation,
            turnSpeed * Time.deltaTime
        );
    }
}

This is only the final movement layer. A production system may add navigation, obstacle avoidance, local steering, animation state changes and different movement speeds.

The key idea remains the same: the formation system provides a meaningful target, and the unit movement layer decides how to reach it.

Keep the formation readable during movement

Teleporting units directly from one layout to another can look unnatural. It is usually better to transition between the old and new slot positions.

For a transition from one formation to another, the system can interpolate each slot:

Vector3 currentSlot = Vector3.Lerp(
    oldSlot,
    newSlot,
    transitionProgress
);

The transition can be triggered when:

the player changes formation type;
the group starts attacking;
the group reaches a waypoint;
a target appears;
the group changes from movement to defense;
units are added or removed.

Formation morphing also works well for non-combat visuals, such as spell patterns, boss attacks and simulation displays.

Add behaviours as independent layers

A formation layout describes where the units should be. A behaviour describes how that layout changes over time.

Useful behaviours include:

rotation;
pulse and wave motion;
phase shifts;
organic noise;
flow noise;
swirl or vortex movement;
follow-target movement;
path and waypoint following;
local cluster splitting;
boids-style steering;
topology changes.

Keeping behaviours separate makes them reusable. A rotation behaviour can be applied to a ring, a grid or a custom pattern without duplicating the layout code.

A behaviour stack can also define the order in which modifications are applied:

Base formation
    ↓
Morphing
    ↓
Rotation
    ↓
Noise or pulse
    ↓
Movement and steering

The order matters. Applying rotation before morphing can produce a different result from applying it after morphing.

Do not rebuild expensive work every frame

A formation system can become expensive if it recalculates everything for every unit on every frame.

In many projects, the following data does not need to be rebuilt continuously:

the basic formation layout;
unit-to-slot assignments;
path requests;
neighbour lists;
cached references;
unchanged behaviour parameters.

Instead, update structural data when something meaningful changes:

the unit count changes;
the formation type changes;
spacing changes;
the group receives a new destination;
the current path becomes invalid;
a unit joins or leaves the group.

Then use lightweight movement and steering between structural updates.

Profiling is important here. The best update frequency depends on the project, the number of units, the navigation system and the complexity of the behaviours.

Formation movement and pathfinding are different problems

A formation layout does not automatically solve navigation.

The group may need to move around obstacles, follow a path or keep units from getting stuck. It helps to separate the problems:

The group chooses a destination or path.
The formation generates local positions around the group.
Each unit moves toward its assigned position.
Local steering handles small corrections.
The group updates or rebuilds the formation when the situation changes.

This approach avoids forcing every unit to solve the same high-level navigation problem independently.

For large groups, avoid restarting pathfinding because the target moved by a very small amount. Use meaningful thresholds and cached paths where appropriate.

Use editor previews and debug tools

Formation systems are much easier to develop when the result can be previewed without entering Play Mode.

Useful editor features include:

drawing slot gizmos;
previewing formation rotation;
showing the formation anchor;
displaying unit assignment lines;
previewing enabled behaviours;
editing waypoints visually;
testing different unit counts;
saving and loading example presets.

Debug visualization can reveal problems that are difficult to see from code alone. For example, a formation may appear to move incorrectly because the anchor rotation is wrong, the slot order changes unexpectedly or the assignment method produces crossings.

A reusable ScriptableObject architecture

Formation definitions and behaviours can be stored as reusable assets instead of being hardcoded into individual scenes.

A ScriptableObject-based workflow can store:

formation type;
spacing and dimensions;
behaviour parameters;
movement settings;
preset names;
demo configurations.

This makes it easier to reuse a formation across several scenes and to create variations without duplicating controller code.

It also makes the workflow more accessible to designers who need to tune formations in the Unity Inspector.

Building a reusable formation toolkit

A complete toolkit for Unity group movement can combine:

procedural formation generators;
runtime formation controllers;
behaviour assets;
formation morphing;
target and leader following;
path and waypoint movement;
boids-style group movement;
editor previews;
custom inspectors;
debug gizmos;
interactive demo scenes;
reusable runtime presets.

RomaSoft's Dynamic Formation System follows this structure. It includes 17 formation types, 15 behaviour assets, runtime formation generation, formation morphing, path and waypoint movement, editor previews and an interactive demo browser.

The included formation types cover layouts such as arcs, circles, grids, hex grids, rings, spirals, stars, walls, wedges, paths, text formations and custom positions.

The behaviour assets include options such as boids-style movement, follow target, path following, rotation, pulse, phase shift, organic noise, swirl vortex and topology changes.

The package requires Unity 2022.3 LTS or newer, the Unity Input System and TextMeshPro. The runtime system is render-pipeline agnostic; the included demo is designed for the Built-in Render Pipeline and may require material adjustments when adapted to URP or HDRP.

You can see the system in action in the Dynamic Formation System demo video or check the Unity Asset Store listing for current pricing, compatibility and package details.

Final checklist

Before using a formation system in a production project, check the following:

Is the group anchor separate from individual unit movement?
Are formation slots generated independently from steering?
Are unit assignments stable during normal movement?
Can the formation change without teleporting units?
Are expensive calculations updated only when necessary?
Can the group follow targets and waypoints?
Are there debug gizmos or editor previews?
Can designers tune formations without changing code?
Have you tested the system with realistic unit counts?
Have you profiled CPU time, allocations and frame time?

Readable group movement is the result of several small design decisions rather than one special algorithm. Start with a clear formation model, separate layout from movement, update expensive work deliberately and add behaviours as reusable layers.

That foundation can support RTS squads, tactical units, tower defense waves, boss attack patterns, spell formations and simulation prototypes without turning every group into a collection of unrelated movement scripts.

For more Unity development guides, visit the RomaSoft Guides.

How to Find Missing Scripts in Unity Prefabs Before They Break Your Build

Roman Kalinchuk — Mon, 14 Sep 2026 08:28:39 +0000

How to Find Missing Scripts in Unity Prefabs Before They Break Your Build

A missing script on a Unity prefab is easy to ignore during development.

The prefab may still appear in the Project window. The scene may open normally. Your game may even run for weeks before someone discovers that an important component is no longer attached.

The problem usually appears after:

renaming or moving a script;
deleting an old component;
resolving a merge conflict;
importing an asset package;
changing assembly definitions;
removing a third-party dependency.

Instead of finding these issues manually, we can scan prefabs from the Unity Editor and report missing scripts before they reach a release build.

What does a missing script mean in Unity?

In the Inspector, Unity usually displays the component as:

Missing (Mono Script)

This means that the GameObject still contains a serialized component reference, but Unity cannot resolve the script behind it.

The reference may be broken because the script was:

deleted;
renamed without preserving its .meta file;
moved between assemblies;
excluded by an assembly definition;
removed from a package.

A missing script is not always a crash, but it can cause unexpected behaviour. For example, a prefab may silently lose collision logic, AI behaviour, animation setup or initialization code.

A simple manual solution

For a small project, you can inspect prefabs one by one:

Open a prefab.
Inspect every GameObject in its hierarchy.
Look for Missing (Mono Script).
Remove or repair the component.
Repeat for the next prefab.

This works for a few assets, but it becomes unreliable in a large project.

A better approach is to create an Editor command that scans every prefab automatically.

Scanning prefab assets with an Editor script

Create a file named MissingScriptScanner.cs inside an Editor folder:

using UnityEditor;
using UnityEngine;

public static class MissingScriptScanner
{
    [MenuItem("Tools/Validation/Scan Prefabs For Missing Scripts")]
    public static void ScanPrefabs()
    {
        string[] prefabGuids = AssetDatabase.FindAssets("t:Prefab");
        int prefabCount = 0;
        int affectedPrefabCount = 0;
        int missingScriptCount = 0;

        foreach (string guid in prefabGuids)
        {
            string path = AssetDatabase.GUIDToAssetPath(guid);

            GameObject prefabRoot = PrefabUtility.LoadPrefabContents(path);

            if (prefabRoot == null)
            {
                Debug.LogWarning($"Could not load prefab: {path}");
                continue;
            }

            prefabCount++;

            int missingInPrefab =
                CountMissingScriptsRecursively(prefabRoot);

            if (missingInPrefab > 0)
            {
                affectedPrefabCount++;
                missingScriptCount += missingInPrefab;

                Debug.LogWarning(
                    $"Prefab contains {missingInPrefab} missing script(s): {path}",
                    prefabRoot
                );
            }

            PrefabUtility.UnloadPrefabContents(prefabRoot);
        }

        Debug.Log(
            $"Prefab scan complete. " +
            $"Scanned: {prefabCount}, " +
            $"Affected prefabs: {affectedPrefabCount}, " +
            $"Missing scripts: {missingScriptCount}"
        );
    }

    private static int CountMissingScriptsRecursively(GameObject root)
    {
        int total = 0;

        Transform[] transforms =
            root.GetComponentsInChildren<Transform>(true);

        foreach (Transform current in transforms)
        {
            GameObject gameObject = current.gameObject;

            total += GameObjectUtility
                .GetMonoBehavioursWithMissingScriptCount(gameObject);
        }

        return total;
    }
}

After the script compiles, use:

Tools → Validation → Scan Prefabs For Missing Scripts

The scanner finds all prefab assets, opens them in isolation, checks every GameObject in the hierarchy and reports the affected asset paths in the Console.

Why use `LoadPrefabContents`?

It is tempting to load a prefab using AssetDatabase.LoadAssetAtPath. However, PrefabUtility.LoadPrefabContents is more appropriate when you need to inspect the editable prefab hierarchy.

It also makes the lifecycle explicit:

GameObject prefabRoot = PrefabUtility.LoadPrefabContents(path);

// Inspect the prefab here.

PrefabUtility.UnloadPrefabContents(prefabRoot);

Always unload the prefab contents after inspection. Otherwise, a large scan can leave many loaded objects in memory.

Improving the scanner

The basic version is useful, but a production tool can provide more information.

For example, it can:

display results in a custom EditorWindow;
group missing scripts by folder;
allow double-click navigation to the prefab;
scan scenes in addition to prefabs;
scan only selected folders;
export a CSV report;
fail a CI validation step;
provide a button to remove missing components;
show the GameObject path inside the prefab hierarchy.

The most important improvement is to make the result easy to act on. A list of file paths is better than a manual search, but a clickable validation report is better still.

When should you run this check?

Run the scan:

before creating a release build;
after importing a Unity Asset Store package;
after a large refactoring;
after changing assembly definitions;
after resolving Git merge conflicts;
before submitting a package to the Unity Asset Store.

It is also useful to run the check regularly during development. Finding one broken prefab immediately is much cheaper than discovering twenty broken assets at the end of a project.

A practical validation workflow

A simple Unity validation workflow can look like this:

Scan prefabs for missing scripts.
Scan scenes for missing references.
Check build settings and included scenes.
Check platform-specific settings.
Create a clean test build.
Review warnings and errors.
Only then prepare the release package.

Validation tools do not replace testing, but they remove a class of avoidable project problems.

Conclusion

Missing scripts are usually not difficult to fix. The real problem is discovering them late.

A small Editor script can scan every prefab and turn a fragile manual process into a repeatable validation step. Once the project grows, the same idea can be extended to scenes, references, build settings and release checks.

If you want to explore a more complete workflow, RomaSoft's Smart Prefab Cleaner is designed to inspect and clean Unity prefabs.

You can also find more Unity development guides on the RomaSoft Guides page.

Another Space Asset

Roman Kalinchuk — Mon, 21 Nov 2022 11:26:20 +0000

https://assetstore.unity.com/packages/slug/121408

Customize shape generation in editor
Auto level generation
Easy shape creation in editor
The possibility of infinite autogeneration of levels
Optimized for Mobile
Touch input for mobile and mouse/keyboard input for web and desktop
Input touch controller for mobile
Very simple to Customize

madewithunity #unity3d #indiedev #gamedev #assetstore

Fun Tunnel - Platform Jumper

Roman Kalinchuk — Mon, 21 Nov 2022 11:24:54 +0000

https://assetstore.unity.com/packages/slug/114515

Customize tunnel generation in editor
Infinite level generation
Optimized for Mobile
Touch input for mobile and mouse/keyboard input for web and desktop
Curved world shader
Input touch controller for mobile
Very simple to Customize

madewithunity #unity3d #indiedev #gamedev #assetstore

DEV Community: Roman Kalinchuk

How to Build Readable Unit Formations in Unity (Procedural Layouts + Runtime Behaviours)

Start with a formation anchor

Procedural formation layouts

Different layouts serve different gameplay roles

Assign units to slots predictably

Move units toward formation targets

Keep the formation readable during movement

Add behaviours as independent layers

Do not rebuild expensive work every frame

Formation movement and pathfinding are different problems

Use editor previews and debug tools

A reusable ScriptableObject architecture

Building a reusable formation toolkit

Final checklist

How to Find Missing Scripts in Unity Prefabs Before They Break Your Build

What does a missing script mean in Unity?

A simple manual solution

Scanning prefab assets with an Editor script

Why use LoadPrefabContents?

Improving the scanner

When should you run this check?

A practical validation workflow

Conclusion

Another Space Asset

madewithunity #unity3d #indiedev #gamedev #assetstore

Fun Tunnel - Platform Jumper

madewithunity #unity3d #indiedev #gamedev #assetstore

Why use `LoadPrefabContents`?