Interactable Objects and Properties

Intermediate40-60 minutesWindowsUnturnedUnity Editor

An interactable object is an object asset whose Interactability field is set to a value other than None in its .dat file. These objects respond to player interaction -- the "F" key prompt -- with behaviors defined by the Interactability enum value. Doors that open and close, lights that toggle on and off, storage containers that hold items, alarm systems that trigger on intrusion, traps that damage players, NPC spawn points that host quest givers and merchants, and quest objects that advance mission objectives are all interactable objects. A map that uses interactable objects well creates gameplay systems that players discover and engage with. A map whose interactable objects do not work creates confusion and broken expectations.

This article is a procedural tutorial covering every interactable object type and property configuration available in the Unturned™ Level Editor. It describes the binary state system for doors and lights, the dropper system for item dispensers, note objects for environmental storytelling, rubble objects for destructible props, storage containers with per-instance inventory configuration, NPC spawn point placement and quest linkage, quest object interaction, the object inspector workflow for editing per-instance properties, and the failure modes that cause interactable objects to not respond to player input. The article assumes the reader is familiar with the object placement workflow from the preceding article.

Prerequisites

• A map with completed terrain, lighting, and object placement. The editor must be open and the map must have at least one object placed that has an interactable asset configuration.
• Familiarity with the object browser and object placement workflow from Object Placement and Manipulation.
• Understanding of the object inspector panel (F2) for editing instance properties.
• A collection of interactable object assets available in the map's master bundle or in the vanilla asset library.

What you will learn

• How the interactability system works and what the Interactability enum values control.
• How to place and configure binary state objects (doors, lights, switches).
• How to configure dropper objects for item dispensing.
• How to configure note objects for text display.
• How to configure rubble objects as destructible props.
• How to place and configure storage containers.
• How place NPC spawn points and link them to quests.
• How to configure quest objects for mission progression.
• How to use the object inspector to edit per-instance interactability properties.
• How to diagnose and resolve interactable objects that do not respond to player input.

Background: how the interactability system works

The interactability system is driven by the Interactability field on the object asset's .dat file. When a player looks at an interactable object and presses the "F" key, the engine reads the asset's Interactability type and executes the corresponding behavior. The behavior may be a state toggle (open/close, on/off), an item drop, a text display, or a damage response.

As shown in the flowchart above, the player interaction triggers a behavior determined solely by the asset's Interactability type. The per-instance properties (current binary state, item contents for storage) modify how the behavior executes but do not change the behavior type.

Binary state objects: doors, lights, switches

Binary state objects toggle between two states when the player interacts with them. The states are defined as State 0 (default, typically "off" or "closed") and State 1 ("on" or "open").

Understanding binary state configuration

The binary state behavior is controlled by fields in the object asset's .dat file:

Field	Type	Purpose
Interactability	enum	Must be Binary_State for toggle behavior
Interactability_Delay	float	Cooldown in seconds between state toggles
Interactability_Nav	Nav enum	Controls whether the Nav game object activates or deactivates based on state
Interactability_Power	Power enum	Toggle requires power to interact; Stay requires power to remain in the on state

Placing a binary state object

Step 1: Open the object browser.

Step 2: Locate a door, light, or switch object asset. Door objects are typically named Door_*, light objects are named Light_* or Lamp_*, and switch objects are named Switch_*.

Step 3: Place the object using the standard placement workflow.

Step 4: After placement, select the object and press F2 to open the inspector panel.

Step 5: In the inspector panel, confirm the asset's Interactability field is set to Binary_State. This property is set on the asset and cannot be changed per-instance.

Step 6: Locate the Interactability State field in the inspector. This field shows the current binary state:

State value	Door behavior	Light behavior	Switch behavior
State 0	Closed	Off	Default position
State 1	Open	On	Activated position

Step 7: Change the state value to set the initial state of the object when the map loads. A door that should start open should have State 1.

Configuring door animation

Door animation is driven by an Animation component on a child transform of the object prefab. The animation path is specified in the asset's Interactability_Animation_Component_Path field.

Step 1: In the object inspector, verify that the door object has an animation component path configured.

Step 2: Test the door in-game by approaching it and pressing the "F" key. The door should play its open animation and switch to State 1.

Step 3: Press "F" again while the door is open. The door should play its close animation and switch to State 0.

On-screen appearance: When the player approaches a door, a prompt appears: "Press [F] to open" (when the door is closed) or "Press [F] to close" (when the door is open). The prompt text is controlled by the object's English.dat localization file.

Dropper objects: item dispensers

Dropper objects spawn items when interacted with. They are used for vending machines, loot dispensers, and quest reward distribution.

Configuring a dropper

The dropper configuration is set on the asset level, not per-instance. All instances of a dropper object share the same item drop configuration.

Step 1: The asset must have Interactability Dropper in its .dat file.

Step 2: The Interactability_Drops field defines how many items are dropped per interaction.

Step 3: The Interactability_Drop_# fields (where # is a zero-indexed integer) define the item IDs to drop. For example:

• Interactability_Drop_0 1001 drops item ID 1001.
• Interactability_Drop_1 1002 drops item ID 1002.

Step 4: Place the dropper object in the level. Player interaction triggers the drop.

Step 5: Test in-game by approaching the dropper and pressing "F". The configured items should appear at the dropper's position or near it.

Note objects: text display

Note objects display lines of text when interacted with. They serve environmental storytelling, quest clues, tutorial messages, and informational signage.

Configuring a note

Step 1: The asset must have Interactability Note in its .dat file.

Step 2: The Interactability_Text_Lines field defines the number of text lines to display.

Step 3: The Interactability_Text_Line_# fields define the text content for each line, supporting rich text markup.

Step 4: Place the note object in the level.

Step 5: Test in-game by approaching the note and pressing "F". The text lines display in a UI window.

Localizing note text

The text displayed by a note object can be overridden through the localization system. In the object's English.dat file, add keys matching the Interactability_Text_Line_# fields:

Interactability_Text_Line_0 This is the first line of the note.
Interactability_Text_Line_1 This is the second line.

The localization keys override the values in the .dat file if both are present.

Rubble objects: destructible props

Rubble objects are destructible props that can be damaged by weapons and explosives. When destroyed, they may drop loot, trigger effects, or alert nearby enemies.

Configuring a rubble object

Step 1: The asset must have Interactability Rubble or the dedicated Rubble property block in its .dat file.

Step 2: Configure the rubble properties:

• Rubble_Health defines the health of each destructible section.
• Rubble_Reward_ID links to a spawn table for loot on destruction.
• Rubble_Can_Zombies_Damage enables zombies to attack the object if it blocks their path.

Step 3: Place the rubble object in the level. Player or zombie damage destroys the object after its health is depleted.

Step 4: Test in-game by attacking the rubble object with a weapon. The object should take damage, display hit effects, and eventually break apart, dropping any configured loot.

Storage containers

Storage containers hold items in an internal inventory that players can access by interacting with the container.

Placing a storage container

Step 1: Locate a storage container asset in the object browser. Storage containers are typically named Crate_*, Locker_*, Shelf_*, or Container_*.

Step 2: Place the container using the standard placement workflow.

Step 3: In the object inspector, configure the container's initial contents (if supported). Some container assets support per-instance inventory configuration through custom properties in the inspector.

Step 4: Test in-game by approaching the container and pressing "F". The container's inventory UI opens, allowing the player to deposit or withdraw items.

Storage container properties

Property	Description
Storage capacity	The number of item slots available in the container. Set on the asset.
Storage type	The type of items that can be stored. Some containers restrict storage to specific item types.
Initial contents	Items that appear in the container when the map loads. May be configured per-instance or asset-wide.

NPC spawns

NPC spawn points define where quest givers, merchants, and other non-player characters appear in the map.

Placing an NPC spawn point

Step 1: Open the object browser and apply the NPCs category filter.

Step 2: Select an NPC spawn point object asset. NPC spawn assets are typically named NPCSpawn_* or follow the naming convention of the NPC type.

Step 3: Place the NPC spawn point at the position where the NPC should stand in the world.

Step 4: Select the NPC spawn point and press F2 to open the inspector.

Step 5: In the inspector, configure the NPC spawn point properties:

Property	Description
NPC Asset ID	The GUID of the NPC asset that defines the NPC's appearance, dialogue, and quests
Spawn Rotation	The direction the NPC faces when spawned
Spawn Animation	The idle animation the NPC plays while standing in place

Linking an NPC to a quest

The NPC spawn point references an NPC asset (defined in a separate .dat file). The NPC asset defines the NPC's quest offerings, dialogue trees, and merchant inventory. The quest configuration is part of the NPC asset, not the spawn point.

For the complete NPC asset reference, see the NPC quest system documentation.

Quest objects

Quest objects are interactable objects that trigger quest events or advance quest objectives when the player interacts with them.

Placing a quest object

Step 1: Locate a quest object asset in the object browser. Quest objects are typically named QuestObject_* or use an existing asset with a quest configuration.

Step 2: Place the quest object at the intended location in the world.

Step 3: Configure the quest object's properties in the object inspector. The specific properties depend on the quest system integration.

Quest objects interact with the Quest NPC system and require a configured quest asset to function. See the quest system documentation for the complete quest object configuration workflow.

Editing object properties in the inspector

The object inspector (F2) is the primary tool for editing per-instance properties on all interactable objects.

Opening the inspector

Step 1: Select the placed interactable object in the viewport.

Step 2: Press F2 on the keyboard, or click the Inspect button in the Objects panel.

Step 3: The inspector panel opens, displaying the object's instance properties.

Editable properties for interactable objects

Property	Editable for	Example
Position	All objects	X: 120.5, Y: 32.0, Z: 450.2
Rotation	All objects	X: 0, Y: 90, Z: 0
Scale	All objects	1.0 (uniform)
Material Palette	Objects with palette	Dropdown selecting variant
Interactability State	Binary_State objects	State 0 (closed) or State 1 (open)
Custom Properties	Objects with custom config	Varies by asset

Custom properties

Some interactable objects expose additional properties in the inspector that are specific to that asset type. These properties are defined in the asset's .dat file using the Custom_Properties configuration. The inspector reads these properties and displays editable fields for each.

Custom properties are the mechanism for per-instance configuration of:

• Storage container initial contents
• Light color and range overrides
• Alarm trigger conditions
• Trap damage values
• Quest object objective IDs

Failure mode: interactable object not responding to "F" key input

The most common interactable object failure is an object that shows no prompt or does not respond when the player presses "F".

What it looks like: The player approaches the object. No "Press F to interact" prompt appears. When the player presses F, nothing happens.

Root cause: One of several causes:

1. The object asset's Interactability field is set to None.
2. The object is a drop-in replacement that uses the wrong asset GUID.
3. The Interactability_Delay is set to a very high value, preventing re-interaction after an initial test.
4. The object requires power (Interactability_Power Toggle or Interactability_Power Stay) and no power source is connected.

Resolution steps:

Step 1: Select the object and open the inspector (F2). Confirm the asset type and verify that Interactability is set to a value other than None. If the asset does not have an Interactability field set, the object cannot be interacted with regardless of its visual appearance.

Step 2: If the interactability type is correct, check the Interactability_Delay value. If it is set to a very high number (more than 60 seconds), the player can only interact once per delay period. Reduce the delay to 0.5-2 seconds for standard objects.

Step 3: If the object requires power, verify that a power source (generator, power line) is connected to the object's zone. Without power, objects with Interactability_Power Toggle or Stay do not respond to interaction.

Step 4: If the object is a door or animated object, verify that the Interactability_Animation_Component_Path field correctly points to a child transform with an Animation component. If the path is incorrect or the Animation component is missing, the interaction triggers the state change but no animation plays.

Failure mode: door or light shows the wrong state

A door that appears closed but is registered as open in the state system, or a light that appears on but is registered as off.

What it looks like: The object's visual state does not match its interaction state. A door that looks closed shows "Press F to close" as the prompt. A light that looks off illuminates the room.

Root cause: The initial state (State 0 or State 1) was set incorrectly during placement, or the object was placed with the wrong state and the visual mesh does not update to match.

Resolution:

Step 1: Select the object and open the inspector.

Step 2: Locate the Interactability State field.

Step 3: Toggle the state to the opposite value. Confirm the visual updates to match. If the visual does not update, the object's animation or mesh swap system is not responding to the state change.

Step 4: Toggle back to the correct state. Save the map.

Failure mode: dropper does not drop items

A dropper object that shows the interaction prompt but produces no items when activated has a misconfigured drop list.

What it looks like: The player approaches the dropper and presses "F". The prompt confirms the interaction (audio cue or animation) but no items appear.

Root cause: The Interactability_Drops field is set to 0 or the Interactability_Drop_# fields reference item IDs that do not exist in the loaded bundles.

Resolution steps:

Step 1: Open the object asset's .dat file. Verify that Interactability_Drops is set to a positive integer (e.g., Interactability_Drops 1).

Step 2: Verify that the Interactability_Drop_0 field references a valid item ID. Common mistakes include using the item's GUID instead of its numeric ID, or using an ID that collides with an existing item on the map.

Step 3: Test by setting Interactability_Drops 1 and Interactability_Drop_0 to a known-working item ID from the vanilla game (e.g., a bandage or canned food item).

Failure mode: note text does not appear

A note object that triggers on interaction but shows blank text has unpopulated or misconfigured text line fields.

What it looks like: The player approaches the note and presses "F". The note UI opens but displays no text or displays "Text Line 0" or similar placeholder content.

Root cause: The Interactability_Text_Lines field is set to 0 or the text line fields are empty.

Resolution steps:

Step 1: Open the object asset's .dat file. Verify that Interactability_Text_Lines is set to a positive integer matching the number of text lines.

Step 2: Verify that Interactability_Text_Line_0 (and subsequent indices) contain the intended text. Each line field should be a string value.

Step 3: If the text is defined in the asset but the localization file (English.dat) has conflicting entries, the localization takes priority. Remove or correct the localization entries for the note's text line keys.

Failure mode: storage container inventory not accessible

A storage container that appears but does not open when interacted with has a missing or broken inventory component.

What it looks like: The player approaches the container and presses "F". The interaction prompt appears and the interaction sound plays, but no inventory UI opens.

Root cause: The container asset does not have a storage component configured, or the storage component references a missing asset.

Resolution: This is an asset-level issue. In the Unity prefab for the container asset, verify that a storage component (typically Storage or Inventory component) is attached to the prefab. The component defines the container's capacity and storage behavior. Rebuild the master bundle after fixing the prefab.

Failure mode: NPC does not appear at spawn point

An NPC spawn point that produces no NPC when the map loads has an incorrect or missing NPC asset reference.

What it looks like: The NPC spawn point object is visible in the editor but no NPC character appears at its position when the map is loaded in-game.

Root cause: The NPC spawn point's NPC Asset ID field references a GUID that does not match any NPC asset in the loaded bundles.

Resolution steps:

Step 1: Select the NPC spawn point and open the inspector (F2).

Step 2: Verify the NPC Asset ID field contains the correct GUID of an NPC asset that is present in the map's bundles.

Step 3: If the GUID is correct but the NPC still does not appear, verify that the NPC asset's .dat file and master bundle are included in the map export.

Failure mode: quest object interaction does not advance quest

A quest object that plays the interaction animation but does not advance the quest objective has a broken quest linkage.

What it looks like: The player presses "F" on the quest object. The interaction plays (sound, animation) but the quest objective does not update. The quest log shows the objective as incomplete.

Root cause: The quest object's Quest_Objective_ID or equivalent property does not match the objective ID defined in the quest asset.

Resolution: Verify the quest object's objective ID in the inspector matches the objective ID in the quest asset's configuration. Quest objectives are defined in the quest asset's .dat file; the object references a specific objective by ID. If the IDs do not match, the quest system does not register the interaction as objective progress.

Failure mode: trap object does not damage players

A trap object that does not damage players when triggered has a damage value of 0 or is missing the damage component.

What it looks like: The player walks through the trap zone or triggers the trap interaction. The trap animation plays or the trap visually activates, but the player takes no damage.

Root cause: The trap asset's damage configuration is set to 0 or the trap uses an Interactability type that does not include damage behavior.

Resolution: Inspect the trap asset's .dat file. Verify that the damage fields are set to positive values. Trap objects that use Interactability Rubble or a custom Interactability type must have the damage fields correctly configured in the asset file.

FAQs

Why does my door open in the wrong direction?

The door's open direction is determined by the Animation component on the door prefab. The direction is set in Unity when the door animation is authored. To change the open direction, the door asset must be modified in Unity to reverse or change the animation. This is an asset-level change that requires rebuilding the master bundle.

Can I have a door that requires a key?

Key-locked doors are configured through the asset's Interactability_Power and Interactability_Nav fields combined with a key item. The door requires the player to hold a specific item (the key) in their inventory while interacting. The key requirement is configured in the door asset's .dat file through the Require_Item_ID or equivalent field.

How do I make a light that only turns on at night?

Place a light object with Interactability Binary_State. Set the light's initial state to State 0 (off). Configure the Level Settings to set the light's state based on time of day. Alternatively, use the lighting panel's time-of-day color system to configure dynamic lighting rather than a toggleable light.

Can I have a container with infinite storage capacity?

Container capacity is set on the asset level. The maximum practical capacity is 200 slots. Values above 200 may cause inventory UI performance issues. Infinite storage is not achievable through the asset configuration system.

Why does my alarm keep triggering after I disable it?

The alarm may have Interactability_Power Stay set, meaning it requires constant power to remain in the off state. If the power source is still active, the alarm may reactivate. Set Interactability_Power Toggle to allow the alarm to stay off after disabling, or disconnect the power source.

How do I make a trap that resets after a delay?

Trap reset behavior is configured through the asset's Interactability_Delay field. The delay controls the cooldown between interactions. For a trap that resets after 10 seconds, set Interactability_Delay 10. The trap can trigger again after the delay period expires.

Can I have NPCs that patrol instead of standing in place?

NPC patrol behavior is configured in the NPC asset, not the spawn point. The NPC asset defines the patrol route waypoints, patrol speed, and idle behavior at each waypoint. The spawn point only defines the NPC's initial position and facing direction.

My interactable object shows the wrong prompt text. How do I fix it?

The prompt text is controlled by the object's English.dat localization file. Create or edit the English.dat file in the object's folder with the correct text keys. For a door, the keys are typically Interactability_Text_Use_0 (for State 0 prompt) and Interactability_Text_Use_1 (for State 1 prompt).

How do I make an object that can only be interacted with once?

Set Interactability_Delay to a very high value (99999 seconds). The player can interact once, and the delay prevents further interaction for the lifetime of the server session. The object's state remains at the toggled value permanently.

Can I have a single object with multiple interaction behaviors?

No. Each object asset has a single Interactability type. To achieve multiple behaviors on the same visual object, create separate interaction zones or trigger volumes that respond to player presence rather than direct interaction.

Best practices

• Test every interactable object in single-player after placement. Interaction behavior that works in the editor may not work in-game.
• Set Interactability_Delay to 0.5-2 seconds for standard doors and toggles. Players expect rapid response.
• Use the object inspector to set the initial state of binary state objects. A door that should start open must have its state set to State 1 before the map is exported.
• Verify the Interactability_Animation_Component_Path on animated objects. An incorrect path causes the interaction to play with no visual feedback.
• Include the English.dat localization file for every interactable object that should display custom prompt text.
• Place NPC spawn points on valid navmesh surface. NPCs that spawn off the navmesh may not move or may clip through geometry.
• For storage containers, test the container capacity and item type restrictions in single-player before publishing.
• Keep trap damage values balanced. The cohort recommendation is 5-15 damage per trigger for standard traps and 25-50 for high-difficulty traps.

Advanced considerations

Power system integration

Objects with Interactability_Power Toggle or Interactability_Power Stay require a power source to be usable. Power sources are placed as separate objects (generators, power lines). The power system uses a zone-based model: the power source powers objects within a defined radius. Objects outside the radius receive no power and remain in their default unpowered state. For maps that use the power system extensively, verify that all powered interactable objects are within range of a power source.

Custom interactability types

The Interactability enum supports values defined by the game engine (None, Binary_State, Dropper, Note, Rubble). Custom interactability types require source code modification of the Useable scripts, which is outside the scope of standard map modding. The cohort recommendation is to achieve custom interaction behavior through the existing interactability types combined with trigger zones and server-side plugins.

NPC quest chains

NPCs can be configured with quest chains: a sequence of quests that progress from one to the next. The chain progression is defined in the NPC asset's quest array. Each quest in the chain has a prerequisite quest ID that must be completed before the next quest becomes available. Quest objects in the world interact with the quest chain by marking objectives as complete, which triggers the next quest in the chain.

Appendix A: Interactability types reference table

Interactability type	Behavior	Per-instance state	Common uses
None	No interaction	None	Decorative objects, props
Binary_State	Toggle between State 0 and State 1	Yes (State 0 or 1)	Doors, lights, switches, alarms
Dropper	Spawn items from drop list	No (asset-wide)	Vending machines, loot dispensers
Note	Display text lines in UI	No (asset-wide)	Signs, notes, quest clues
Rubble	Damageable, destructible	Yes (remaining health)	Destructible walls, crates, barriers

Appendix B: Interactable object failure mode diagnostic table

Symptom	Most likely cause	Resolution
Object shows no "F" prompt	Interactability set to None on asset	Set Interactability to a non-None value in asset .dat
Object shows prompt but no response on F	Interactability_Delay too high or power missing	Reduce delay; verify power source
Door animation does not play	Animation component path incorrect	Fix Interactability_Animation_Component_Path
Object visual state mismatched with prompt	Initial state set incorrectly	Toggle state in inspector to match visual
Dropper produces no items	Interactability_Drops is 0 or drop IDs invalid	Set positive drops count; use valid item IDs
Note shows blank text	Interactability_Text_Lines is 0 or lines empty	Set positive lines count; populate text fields
Container does not open	Missing storage component on prefab	Add storage component in Unity prefab
NPC does not appear at spawn	NPC Asset ID GUID is incorrect or missing	Verify GUID matches existing NPC asset
Quest interaction does not advance quest	Objective ID mismatch between object and quest	Align objective IDs
Trap does no damage	Damage fields set to 0 on asset	Set positive damage values in asset .dat

Appendix C: Binary state object configuration quick-reference

Object type	State 0	State 1	Typical Delay	Power requirement
Door	Closed	Open	0.5-1.0 sec	None
Light	Off	On	0.3 sec	Toggle
Alarm	Disarmed	Armed	1.0 sec	Stay
Switch	Off	On	0.5 sec	None
Gate	Closed	Open	1.0-2.0 sec	None

Authoring checklist

Before publishing a map with interactable objects, confirm the following:

• [ ] Every interactable object has been tested in single-player
• [ ] Binary state objects start in the correct initial state
• [ ] Door animations play correctly in both open and close directions
• [ ] Dropper objects produce the intended items at the intended count
• [ ] Note objects display the correct text lines
• [ ] Storage containers are accessible and have the correct capacity
• [ ] NPCs appear at their spawn points and offer quests correctly
• [ ] Quest object interactions advance quest objectives
• [ ] Traps deal the intended damage values
• [ ] Power-requiring objects have a valid power source within range
• [ ] Localization files provide the correct prompt text

Cross-references

• Object Placement and Manipulation -- the previous article; covers the object placement workflow that precedes interactable configuration.
• Object Culling and Static Batching -- the next article; covers performance optimization for placed objects.
• Objects and Structures Assets -- the object asset .dat field reference including Interactability configuration.
• Material Palette Asset Reference -- material palette configuration for object visual variants.
• Navmesh and Pathfinding -- navmesh interaction for NPC spawn points and interactable objects.
• Smartly Dressed Games modding documentation -- official field reference.
• Unturned on Steam -- game page and community.

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Binary state objects, droppers, notes, rubble, storage, NPC spawns, quest objects, inspector properties, failure mode documentation.