Batch Edit Hundreds of Actors with UnrealPilot

The Problem with Manual Editing

You've placed 200 lights in your level. Now the art director wants them all to be slightly warmer. Or you've imported 500 static meshes and need to enable complex collision on all of them. Or you need to move every actor tagged "foliage" up by 10 units because the ground plane changed.

In vanilla Unreal, you have three options:

• Select all, hope the property appears in the multi-edit panel, change it
• Write a Python or C++ editor utility
• Click through each actor one at a time

The first option works sometimes but fails for complex operations. The second requires context-switching into coding mode. The third is soul-crushing.

UnrealPilot offers a fourth option: describe what you want, and it happens.

Basic Batch Property Changes

The simplest batch operations change a property on multiple actors:

"Set all PointLights in the level to intensity 5000"

UnrealPilot finds every PointLight actor, accesses its intensity property, and sets the value. One command, hundreds of changes.

Targeting by Actor Type

"Set all StaticMeshActors to cast dynamic shadows"
"Disable collision on all DecalActors"
"Set all SpotLights to inner cone angle 30"

Targeting by Selection

"Set the selected actors' mobility to Movable"
"Scale the selected meshes to 1.5"
"Rotate selected actors 45 degrees on the Z axis"

Targeting by Tag

"Set all actors tagged 'destructible' to simulate physics"
"Hide all actors tagged 'debug'"
"Set mobility to Static on all actors tagged 'environment'"

Targeting by Name Pattern

"Set all actors starting with 'Light_' to intensity 3000"
"Disable all actors containing 'Placeholder' in their name"
"Delete all actors ending with '_OLD'"

Conditional Batch Operations

Real batch operations often have conditions:

"Set all PointLights with intensity above 10000 to intensity 10000"
"Delete all StaticMeshActors with no mesh assigned"
"Hide all actors more than 5000 units from the player start"

UnrealPilot evaluates conditions for each actor and only modifies those that match.

Combining Conditions

"Set all PointLights that are red and have intensity above 5000 to orange"
"Delete all StaticMeshActors tagged 'temp' that have no collision"
"Select all SpotLights within 1000 units of the selected actor that are not casting shadows"

Mass Spawning Patterns

Spawning many actors with specific arrangements is tedious manually. UnrealPilot handles common patterns:

Grid Patterns

"Spawn a 10x10 grid of SM_FloorTile with 200 unit spacing"
"Create a 5x5x3 grid of PointLights with 500 unit spacing"
"Spawn BP_Enemy in a 4x4 grid centered on the selected actor"

Circle Patterns

"Spawn 12 torches in a circle of radius 500 around the selected actor"
"Create 8 SpotLights in a ring pointing inward at the center"
"Place 20 columns evenly spaced in a circle of radius 1000"

Line Patterns

"Spawn 10 barriers in a line from here to the selected actor"
"Create lights every 200 units along the X axis for 2000 units"
"Place fence posts between the two selected actors with 100 unit spacing"

Random Distribution

"Scatter 50 rocks randomly within 1000 units of here"
"Spawn 30 trees randomly in the selected volume"
"Place 100 debris actors randomly across the level floor"

Find and Replace Operations

Sometimes you need to swap one thing for another across your level:

Replacing Actor Classes

"Replace all BP_OldEnemy actors with BP_NewEnemy"
"Swap all SM_TreeOld static meshes for SM_TreeNew"
"Replace all PointLights with SpotLights keeping the same location and color"

Replacing Meshes

"Change all StaticMeshActors using SM_Chair_01 to use SM_Chair_02"
"Replace the mesh on all actors tagged 'placeholder' with SM_FinalAsset"
"Swap all instances of SM_Rock_A with a random selection from SM_Rock_A, SM_Rock_B, SM_Rock_C"

Replacing Materials

"Replace M_OldWood with M_NewWood on all static mesh actors"
"Set material slot 0 to M_Glass on all actors using M_Placeholder"
"Apply M_Damaged to all destructible actors"

Bulk Transform Operations

Moving, rotating, or scaling many actors at once:

Translation

"Move all foliage actors down by 10 units"
"Shift all lights tagged 'ceiling' up by 300 units"
"Move the selected actors 500 units in the direction they're facing"

Rotation

"Rotate all selected actors to face the player start"
"Add 15 degrees of random Y rotation to all tree actors"
"Align all wall actors to the nearest 90 degree angle"

Scaling

"Scale all actors tagged 'small' by 0.5"
"Randomly scale all rocks between 0.8 and 1.2"
"Set all debris to uniform scale 0.3"

Organizational Batch Operations

Keeping levels organized requires batch operations too:

Naming

"Rename all PointLights to 'Light_' followed by a number"
"Add prefix 'ENV_' to all actors in folder Environment"
"Remove '_TEMP' suffix from all actor names"

Tagging

"Tag all StaticMeshActors in the selected area as 'zone_1'"
"Add tag 'destructible' to all actors with physics enabled"
"Remove tag 'old' from all actors"

Layer Assignment

"Move all lights to the Lighting layer"
"Put all foliage actors in the Foliage layer"
"Assign selected actors to a new layer called 'Interactive'"

Folder Organization

"Move all PointLights to the Lights folder in the outliner"
"Create subfolders by actor type under Environment"
"Organize all actors into folders based on their tags"

Complex Multi-Step Operations

Real workflows often require multiple operations in sequence:

"Find all lights with intensity above 8000, tag them as 'bright',
and set their attenuation radius to 2000"

"Select all actors within 500 units of any enemy spawner,
enable collision on them, and tag them as 'combat_area'"

"For each selected actor, spawn a point light 200 units above it
with intensity proportional to the actor's scale"

UnrealPilot breaks down complex requests into steps and executes them in order.

Undo and Safety

Batch operations are powerful. Power requires safety:

• Preview mode: Ask UnrealPilot what it will do before executing. "What would happen if I deleted all actors tagged 'temp'?"
• Undo support: All batch operations integrate with Unreal's undo system. Ctrl+Z reverses the entire batch.
• Selection first: For destructive operations, UnrealPilot often selects the targets first so you can verify before confirming.

Performance Considerations

Batch operations on thousands of actors can take time. Some tips:

• Filter early: "Set intensity on all lights in the selected sublevel" is faster than "Set intensity on all lights" in a large project.
• Use tags: Tag-based queries are faster than property-based conditions.
• Break up huge operations: If you're modifying 10,000 actors, consider doing it in batches of 1,000.

Comparison: Script vs UnrealPilot

Here's the same operation in Python and UnrealPilot:

Python Editor Utility

import unreal

# Get all actors
actors = unreal.EditorLevelLibrary.get_all_level_actors()

# Filter to point lights
point_lights = [a for a in actors
                if a.get_class().get_name() == "PointLight"]

# Filter by intensity
bright_lights = []
for light in point_lights:
    component = light.get_component_by_class(
        unreal.PointLightComponent
    )
    if component and component.intensity > 5000:
        bright_lights.append((light, component))

# Modify each
for light, component in bright_lights:
    component.set_editor_property("intensity", 5000)
    light.tags.append("was_bright")

print(f"Modified {len(bright_lights)} lights")

UnrealPilot

"Set all PointLights with intensity above 5000 to intensity 5000 and tag them 'was_bright'"

The Python script takes 15 lines and requires knowing the API. The UnrealPilot command takes one line and requires knowing what you want.

Python is more flexible for truly custom operations. UnrealPilot is faster for common operations.

Real-World Examples

Lighting Pass

"Select all PointLights in the level"
"Set selected lights to cast shadows"
"Set shadow resolution scale to 0.5 on lights with intensity below 2000"
"Tag all lights with intensity above 8000 as 'key_light'"
"Set all key_light tagged lights to use ray traced shadows"

Performance Optimization

"Set all StaticMeshActors more than 10000 units from player start to cull distance 5000"
"Disable collision on all actors tagged 'detail'"
"Set LOD bias to 2 on all foliage instances"
"Merge all StaticMeshActors in the selected area into a single actor"

Level Cleanup

"Delete all actors with 'test' in their name"
"Remove all empty actors"
"Delete all lights with intensity 0"
"Find and delete all actors outside the level bounds"

Asset Swap

"Replace all SM_Rock_Placeholder with SM_Rock_Final"
"Swap all M_Prototype materials with M_Production"
"Replace all BP_EnemyBasic in zone_3 with BP_EnemyHard"

Tips for Effective Batch Commands

• Be specific about targets: "All lights" vs "All PointLights in the Caves sublevel" makes a big difference.
• Use tags consistently: A well-tagged level makes batch operations much more precise.
• Start with selection: "Select all X" lets you verify before "Delete all X".
• Ask before destructive ops: "How many actors would be deleted if I..." gives you a count first.

Get Started with Batch Operations

Batch operations are one of UnrealPilot's most time-saving features. Tasks that would take hours of clicking become single commands. Request beta access and start automating your level editing.

Request beta access →