Unturned Objects, Structures, and Barricades Asset Guide

Intermediate40-60 minutesWindowsUnity EditorBlenderNotepad++

Unturned™ separates placed content into three asset categories that look similar from a player's perspective but behave very differently under the engine: Objects, Structures, and Barricades. Getting the category wrong at the start of a mod costs the entire .dat authoring pass, because the field sets do not overlap — a Barricade .dat read as a Structure type will fail to load, and a Structure .dat with object-type flags will produce incorrect physics behavior in-game.

This guide is the 57 Studios™ reference for all three asset categories. It covers every major .dat field for each category, maps out the Object sub-types (small, medium, large, decal, NPC, resource), lists the Structure Type enum values with their gameplay implications, documents the Barricade can-place-on flag matrix, and catalogs the collision and navmesh pitfalls that cause silent failures during playtesting. Modders who need the prerequisite Unity setup workflow should complete Project Folder Structure and GUIDs before working through this guide.

The three-category mental model

Before opening a .dat file, confirm which category your asset belongs to. The following definitions are precise — they do not correspond to what the asset looks like, only to how it functions.

Category	Who places it	Destroyable by players?	Persists across server restarts?	Example
Object	Map designers (in the level editor), not players at runtime	Only by the server or map designer in the editor	Yes — it is baked into the level	Fallen log, abandoned car, mailbox, decal on a wall, NPC spawn point
Structure	Players at runtime, using construction items (planks, metal sheets, etc.)	Yes — other players can damage and destroy it	Yes — saved to the server save file	Wooden wall, metal floor, roof panel, pillar, rampart
Barricade	Players at runtime, using deployable items (sandbag, wire, bed, sign, etc.)	Yes — other players can damage and destroy it	Yes — saved to the server save file	Sandbag, wire fence, sleeping bag, storage crate, spike strip

The clearest decision rule: if a player can pick up the item from their inventory and place it in the world, it is either a Structure or a Barricade. If it appears in the level editor and is baked into the map as decoration or level geometry, it is an Object.

Structures and Barricades are the two runtime-placeable categories. They differ in how they interact with the building system. Structures are architectural — they snap to the structural grid and form walls, floors, and roofs. Barricades are deployable — they do not need to snap to a structural grid and are typically placed on terrain, on floors, or on existing structures.

Object assets

What Objects are

An Object asset is a decoration or functional element placed in the level editor by a map designer. Players do not place Objects at runtime; the map designer uses the Unturned™ level editor to position them and they become part of the map's static or semi-static scene. Objects include landscape features (boulders, logs), urban props (mail boxes, dumpsters, streetlights), decals (damage marks, paint stencils), NPC markers, and resource nodes (trees, ore veins) when authored as Object-type assets.

The Object asset type is the largest category by asset count in vanilla Unturned™, and it is the category most used in custom maps produced with the 57 Studios™ map workflow.

Object sub-types

The Type field on an Object .dat controls behavior in the level editor, collision generation, and runtime interaction. The six sub-types are:

Sub-type value	Behavior	Typical use
Small	Low-profile decoration. Treated as non-blocking by the navmesh bake. Minimal collision envelope.	Rocks, flower pots, small props
Medium	Mid-size decoration. May block the navmesh depending on collision volume.	Mailboxes, barrels, crates, vehicle wrecks
Large	Large decoration. Navmesh treats this as a full obstacle; navmesh carves around the collision hull.	Shipping containers, dumpsters, trees, large ruins
Decal	No physics collision. Projected as a world-space decal onto underlying geometry.	Graffiti, blood splatter, paint marks, road markings
NPC	Spawns an NPC character at runtime. Invisible at rest; triggers NPC spawn logic.	Quest giver spawn points, merchant locations
Resource	Marks a harvestable node. Paired with a Resource Asset .dat that defines yield and respawn.	Trees, ore veins, berry bushes

Sub-type collision and navmesh interaction

The sub-type is the most consequential choice for collision and navmesh authoring. Small objects are ignored by the navmesh baker, which means zombie pathfinding passes through them — correct for small decorations, wrong for objects that should physically block zombies. Large objects trigger full navmesh carving. Choose Medium for objects that should have collision but probably should not hard-carve the navmesh. See the Collision and navmesh pitfalls section for the full pitfall list.

Object .dat fields

The minimum required fields for a valid Object .dat are ID, GUID, Type Object, and the Object_Type sub-type. The full recommended field set is:

Identity fields

Field	Type	Example	Required	Purpose
ID	uint16	50001	Yes	Unique asset ID. Use IDs in the 50000+ range for custom mods to avoid collisions with vanilla and established community mods.
GUID	uint128	a1b2c3d4e5f6708192a3b4c5d6e7f801	Yes	Globally unique identifier. Generate a fresh GUID for each asset. See Project Folder Structure and GUIDs.
Type	enum	Object	Yes	The asset category. Must be Object for this asset type.
Object_Type	enum	Medium	Yes	The object sub-type. One of: Small, Medium, Large, Decal, NPC, Resource.
Name	string	AbandonedMailbox	Yes	The internal asset name. Appears in the level editor's asset picker.

Gameplay fields

Field	Type	Default	Purpose
Interactability	enum	None	How players interact with the object. None = no interaction; Binary_State = two-state toggle (e.g., a door that opens/closes); Note = readable text note.
Is_Binary_State_Collision	flag	(absent)	When present, the object has different collision meshes for each binary state. Used for doors: state 0 = closed collision, state 1 = open collision.
Use_Water_Height_Transparent_Sort	flag	(absent)	When present, the object's renderer sorts with water-height transparency. Use for partially-submerged objects.
Foliage_Instancing	flag	(absent)	When present, the engine applies GPU instancing to this object for rendering performance. Use on objects placed many hundreds of times in a level (grass tufts, small rocks).
Allow_Structures	flag	(absent)	When present, players can build Structures on top of this object. Relevant for large objects that could serve as a base platform.

Localization

Each Object asset has an English.dat in its asset folder with two fields:

Field	Purpose
Name	The display name shown in the level editor and in-game tooltip.
Hint	The hint text shown when the player's cursor passes over an interactable object.

Example Object .dat — Medium interactable door

ID 50001
GUID a1b2c3d4e5f6708192a3b4c5d6e7f801
Type Object
Object_Type Medium

Interactability Binary_State
Is_Binary_State_Collision

# English.dat
Name Abandoned Mailbox
Hint Open the mailbox.

Decal objects require a separate shader

Decal objects use a projection shader rather than the standard surface shader. If you assign a standard material to a Decal-type object, the decal will appear as a floating polygon rather than projecting onto underlying geometry. Author decal materials with the Unturned™ decal shader before assigning them to the prefab.

---

Structure assets

What Structures are

A Structure asset is a player-constructable architectural element that snaps to the Unturned™ structural grid. Players craft Structures from raw materials (planks, metal sheets, wire) and place them in the world from their inventory. Structures form the walls, floors, roofs, posts, pillars, and ramparts of player-built bases.

Structures interact with the building system: the engine validates placement against the structural grid, applies snap logic, and enforces the Range field (how far away a player can place the structure). Structures are saved to the server save file and persist across restarts.

Structure Type enum values

The Type field on a Structure .dat is not the same as the Type Object / Type Barricade top-level category field. The Structure sub-type Type field controls grid snapping, placement validation, and the structural audio set the engine applies. The six values are:

Type value	Grid behavior	Typical geometry	Notes
Wall	Snaps to wall positions on the structural grid. Requires a vertical face.	Flat vertical panel — 3 m × 3 m or 4 m × 3 m for standard walls.	Walls connect to Floors and Pillars. A valid base requires at least one Floor and one Wall if the base is to have an interior.
Floor	Snaps to floor positions. Horizontal placement.	Flat horizontal panel — 3 m × 3 m standard.	Floors are the base grid unit from which other structure types extend. Placement of the first Floor piece establishes the grid origin.
Roof	Snaps above Walls.	Angled or flat horizontal panel.	Roofs require Walls below them on the structural grid to be valid placements.
Post	Snaps to corner positions on the structural grid. Vertical column.	Square vertical column — 0.5 m × 0.5 m × 3 m standard.	Posts connect to other grid positions without requiring a Floor center. Useful for walkways, bridges, and lofted platforms.
Pillar	Snaps to edge positions on the structural grid. Vertical face support.	Thin vertical element along a Wall edge.	Pillars reinforce Wall edges and are required by some grid configurations for a valid placed Wall.
Rampart	Snaps to Wall positions. Used for stepped or angled parapet walls.	Angled or crenelated wall panel.	Ramparts behave like Walls for placement logic but typically have geometry designed for cover angles.

Choosing the right Structure Type

The Type field controls only placement logic and audio; it does not modify collision or damage behavior. Two mods can produce geometrically identical meshes, assign different Type values, and produce different in-game placement behavior. A mesh that should function as a wall must use Type Wall, even if the geometry resembles a floor panel rotated 90 degrees.

Structure .dat fields

Identity fields

Field	Type	Example	Required	Purpose
ID	uint16	50100	Yes	Unique asset ID.
GUID	uint128	b2c3d4e5f6a70182930a4b5c6d7e8f90	Yes	Globally unique identifier.
Type	enum	Structure	Yes	Top-level asset category. Must be Structure.
Name	string	WoodWall	Yes	Internal asset name.
Rarity	enum	Common	No	Inventory rarity tier: Common, Uncommon, Rare, Epic, Legendary, Mythical.
Slot	enum	Structure	Yes	Inventory slot category. Must be Structure for structure items.
Size_X / Size_Y	uint8	1 / 1	Yes	Inventory grid footprint. Standard structure items are 1×1.

Gameplay fields

Field	Type	Default	Purpose
Health	uint16	500	The structure's hit points. How much damage the structure absorbs before destruction.
Range	float	4.0	Maximum placement distance in meters from the player.
Type (sub-type)	enum	Wall	The structural sub-type. One of: Wall, Floor, Roof, Post, Pillar, Rampart. This is a second Type field on structures — the top-level Type Structure and the sub-type Type Wall are separate keys. In the .dat file, both appear as Type; the parser reads the first occurrence as the asset category and the second as the structure sub-type.
Eligible_For_Pull	bool	false	When true, the structure can be pulled by a player using a salvage tool without destroying it.
Armor_Tier	enum	(absent)	When present, modifies damage scaling. LowCaliber and HighCaliber determine which damage category applies full/reduced damage.
Explosion	uint16	0	The explosion asset ID to spawn when the structure is destroyed. 0 = no explosion.
Proof_Explosion	flag	(absent)	When present, the structure takes zero damage from explosion-type damage.
Unpickupable	flag	(absent)	When present, the structure cannot be salvaged at all. Use for environment-level structures that should be permanent.

Craft fields (crafting recipe)

Structure items are typically crafted from raw materials. The crafting recipe lives in the item .dat:

Field	Type	Example	Purpose
Blueprints	uint8	1	Number of crafting blueprints this item has.
Blueprint_0_Type	enum	Repair	Blueprint type: Craft, Repair, Tool, etc.
Blueprint_0_Supplies	uint8	1	Number of input items for blueprint 0.
Blueprint_0_Supply_0_ID	uint16	76	The item ID of the first input ingredient (e.g., planks).
Blueprint_0_Supply_0_Amount	uint8	3	Quantity of the first input ingredient.
Blueprint_0_Product	uint16	50100	The item ID produced by the blueprint (should match the structure's own ID).
Blueprint_0_Products	uint8	1	Quantity produced.

Example Structure .dat — Wooden wall

ID 50100
GUID b2c3d4e5f6a70182930a4b5c6d7e8f90
Type Structure
Name WoodWall
Rarity Common
Slot Structure
Size_X 1
Size_Y 1

Type Wall
Health 500
Range 4.0
Eligible_For_Pull true

Blueprints 1
Blueprint_0_Type Craft
Blueprint_0_Supplies 1
Blueprint_0_Supply_0_ID 76
Blueprint_0_Supply_0_Amount 5
Blueprint_0_Product 50100
Blueprint_0_Products 1

# English.dat
Name Wooden Wall
Description A plank wall panel for base construction. Snaps to the structural grid.

The double Type field

Structure .dat files contain two Type fields — the asset-level Type Structure and the sub-type Type Wall (or Floor, Roof, etc.). Both fields use the key name Type. This is not a typo; the Unturned™ parser reads them in order. Do not collapse them into one. A Structure .dat that is missing the sub-type Type field will default to a fallback behavior that may not match the intended grid placement.

Structure health reference

The following table provides health reference values from vanilla Unturned™ structures, useful as a starting point for custom structure tuning.

Material tier	Type	Typical Health	Notes
Wood	Wall	500	Standard wooden plank wall.
Wood	Floor	500	Standard wooden plank floor.
Wood	Roof	400	Slightly less durable than wall/floor.
Metal	Wall	1800	Corrugated metal wall, substantially more durable.
Metal	Floor	1800	Corrugated metal floor.
Metal	Roof	1500	Metal roof panel.
Plate	Wall	3500	Armored plate wall, top vanilla tier.
Plate	Floor	3500	Armored plate floor.

Custom structures should fall somewhere in this range unless designed for a specific gameplay purpose (e.g., an extremely fragile prop structure, or an indestructible setpiece structure with Health 65535).

---

Barricade assets

What Barricades are

A Barricade asset is a player-deployable item that places an object in the world without requiring the structural grid. Players carry Barricades in their inventory and deploy them on terrain, on floors, on vehicles, or on other structures depending on the can-place-on flag configuration in the .dat.

Barricades cover a wide range of functional types: defensive props (sandbags, wire fences, spike strips), storage (crates, lockers, fridges), player utilities (sleeping bags, campfires, sentries), and interactive props (signs, alarms, generators). What they share is that they are placed freely without grid snapping and destroyed by player-dealt damage.

Barricade can-place-on flags

The can-place-on field set controls which surfaces accept a barricade as a valid placement target. These are additive flags; a barricade can have multiple can-place-on flags active simultaneously.

Flag	Meaning	Typical use case
Can_Place_On_Ground	The barricade can be placed on terrain.	Sandbags, campfires, tents — any item that typically goes on the ground.
Can_Place_On_Floor	The barricade can be placed on a Structure floor panel.	Storage crates, sleeping bags, sentries — items placed inside a base.
Can_Place_On_Ceiling	The barricade can be placed on the underside of a Structure roof or floor from below.	Lamps, hanging decorations.
Can_Place_On_Wall	The barricade can be placed on a Structure wall face.	Mounted lights, mounted signs, shelves.
Can_Place_On_Vehicle	The barricade can be placed on a vehicle's placement surface.	Vehicle-mounted turrets, sandbag fortifications on trucks.

Combining flags for flexible placement

Most Barricades should have Can_Place_On_Ground as a baseline. Add Can_Place_On_Floor for items that belong inside player bases. Add Can_Place_On_Vehicle only for items explicitly designed for vehicle mounting — a storage crate placed on a moving vehicle will produce physics instability unless the Barricade's physics configuration accounts for the vehicle's movement. See Collision and navmesh pitfalls for details.

Barricade .dat fields

Identity fields

Field	Type	Example	Required	Purpose
ID	uint16	50200	Yes	Unique asset ID.
GUID	uint128	c3d4e5f6a7b801920a1b2c3d4e5f6a7b	Yes	Globally unique identifier.
Type	enum	Barricade	Yes	Top-level asset category. Must be Barricade.
Name	string	CustomSandbag	Yes	Internal asset name.
Rarity	enum	Common	No	Inventory rarity tier.
Slot	enum	Barricade	Yes	Inventory slot category. Must be Barricade.
Size_X / Size_Y	uint8	1 / 1	Yes	Inventory grid footprint.

Gameplay fields

Field	Type	Default	Purpose
Health	uint16	200	The barricade's hit points.
Range	float	3.0	Maximum placement distance from the player in meters.
Can_Place_On_Ground	flag	(absent)	Enables placement on terrain.
Can_Place_On_Floor	flag	(absent)	Enables placement on structure floors.
Can_Place_On_Ceiling	flag	(absent)	Enables placement on ceilings / floor undersides.
Can_Place_On_Wall	flag	(absent)	Enables placement on structure wall faces.
Can_Place_On_Vehicle	flag	(absent)	Enables placement on vehicle surfaces.
Unpickupable	flag	(absent)	When present, the barricade cannot be salvaged.
Unsalvageable	flag	(absent)	When present, salvaging the barricade yields no materials.
Unrepairable	flag	(absent)	When present, the barricade cannot be repaired by a player.
Explosion	uint16	0	Explosion asset ID spawned on destruction.
Proof_Explosion	flag	(absent)	When present, the barricade is immune to explosion damage.
Invulnerable	flag	(absent)	When present, the barricade cannot be damaged at all. Use for decorative server props that should not be destructible.

Interactability fields

Barricades support a richer interactability system than Objects, because they are runtime-placed items that players interact with.

Field	Type	Purpose
Interactability	enum	One of: None, Binary_State, Dropper, Note, Fuel, Charge, Farm, Rubble, Sign, Sign_Quests, Bed, Claim, Door, Hatch, Storage, Sentry, Library, Mannequin, Generator, Spot
Interactability_Health	uint16	For generators and fuel tanks: the fuel/charge capacity.
Interactability_Text	string	For Note type: the text content of the note.
Interactability_Delay	float	Delay in seconds before the interaction triggers.
Interactability_Reset	float	For Binary_State: time in seconds before the state automatically resets. 0 = no auto-reset.
Interactability_Storage_X / _Y	uint8	For Storage type: the grid dimensions of the storage interface.
Interactability_Locked	flag	When present, the barricade starts in a locked state and requires a key or PIN to interact.

Example Barricade .dat — Custom sandbag

ID 50200
GUID c3d4e5f6a7b801920a1b2c3d4e5f6a7b
Type Barricade
Name CustomSandbag
Rarity Common
Slot Barricade
Size_X 1
Size_Y 1

Health 350
Range 3.5

Can_Place_On_Ground
Can_Place_On_Floor

Interactability None

Blueprints 1
Blueprint_0_Type Craft
Blueprint_0_Supplies 1
Blueprint_0_Supply_0_ID 50210
Blueprint_0_Supply_0_Amount 4
Blueprint_0_Product 50200
Blueprint_0_Products 1

# English.dat
Name Custom Sandbag
Description A packed sandbag for defensive fortification. Place on terrain or structure floors.

Example Barricade .dat — Storage crate (2×3 grid)

ID 50201
GUID d4e5f6a7b8c901020a1b2c3d4e5f6a7b
Type Barricade
Name StorageCrate
Rarity Common
Slot Barricade
Size_X 1
Size_Y 1

Health 600
Range 3.0

Can_Place_On_Ground
Can_Place_On_Floor

Interactability Storage
Interactability_Storage_X 2
Interactability_Storage_Y 3

Barricade versus Structure health reference

Barricade class	Typical Health range	Notes
Light decorative prop	50–150	Sandbags, small signs, campfires.
Defensive barrier	200–500	Larger sandbags, wire fences.
Storage container	400–800	Crates, lockers.
Heavy fortification	800–2000	Reinforced barricades, sentry positions.
Invulnerable prop	Use Invulnerable flag	Server decoration that should not be destroyable.

---

Collision and navmesh pitfalls

Collision and navmesh configuration are the leading causes of silent failures in Object, Structure, and Barricade mods. Unlike .dat field errors — which typically produce a console error or a missing asset — collision and navmesh issues produce in-game behavior that appears correct but is actually wrong. The mod loads and the asset appears; the problem surfaces during playtesting.

Pitfall 1: Oversized collision mesh on Small objects

The Small Object sub-type does not automatically carve the navmesh, but it does generate a physics collider from the prefab's collider components. If the collider on a Small object is authored at a significantly larger volume than the visual mesh, players will appear to collide with invisible geometry and zombies will walk around an invisible obstacle that is larger than the visible prop.

Resolution: author collision meshes to match the visual mesh closely. For Small objects, the cohort recommendation is to use a MeshCollider set to convex, derived from a simplified version of the visual mesh. Avoid box colliders on organic shapes.

Pitfall 2: Missing navmesh carve on Large objects

Large objects that should block zombie pathfinding — wrecked vehicles, shipping containers, large walls — must have a NavMeshObstacle component on the prefab (or the level's navmesh must be baked with the object in place). Without either, zombies will walk directly through a large prop.

Resolution: for Large Object sub-type assets, add a NavMeshObstacle Unity component to the prefab root. Set its Shape to Box or Capsule and size it to approximate the walkable footprint of the asset. Set Carve to true. The obstacle will dynamically carve the navmesh at runtime.

Static versus dynamic navmesh carving

If the level's navmesh is pre-baked in the Unity level editor with the object present, the carve is static and does not move with the asset at runtime. For map decoration objects that never move, static baking is preferred (lower runtime cost). For any asset that could be moved or spawned dynamically, use a NavMeshObstacle with Carve: true.

Pitfall 3: Barricade physics instability on vehicles

When a Barricade has Can_Place_On_Vehicle enabled, the barricade's physics Rigidbody must be configured to follow the vehicle's transform without fighting the physics engine. A barricade placed on a moving vehicle will jitter, float, or fall through the vehicle if the Rigidbody is configured incorrectly.

Resolution: for vehicle-mountable barricades, set the Rigidbody's Is Kinematic property to true in the Unity prefab. Kinematic Rigidbodies follow parent transforms without physics simulation, which prevents the jitter. The barricade will still respond to player damage (a script-driven health system, not physics-driven).

Pitfall 4: Structure collision extending outside the grid cell

If a Structure prefab's collision mesh extends beyond the 3 m × 3 m grid cell, placed structures will overlap adjacent grid cells and prevent other structures from being placed next to them. This manifests as an inability to build adjacent walls or floors even when the grid position appears visually empty.

Resolution: author Structure collision meshes to fit within the exact grid cell dimensions. For a standard 3 m Wall, the collision mesh should be exactly 3 m wide and 3 m tall with zero overhang. Add 0.01 m inset margin on shared edges to prevent physics overlap with adjacent structure colliders.

Pitfall 5: Decal z-fighting on near-coplanar geometry

Decal type Objects project onto underlying geometry. When the underlying geometry is very close to coplanar with another surface (e.g., a decal placed on a wall that has another wall directly adjacent), the projection may flicker between the two surfaces — a z-fighting artifact.

Resolution: configure the decal material's depth offset property to provide a small positive offset from the underlying surface. The Unturned™ decal shader supports a depth bias parameter for this purpose. The cohort's default value is 0.02.

Pitfall 6: NPC Object sub-type with no NPC asset linked

An NPC Object sub-type placed in the level editor must have a corresponding NPC asset configuration that specifies the NPC's character model, dialogue, and quest state. If the NPC Object is placed without a linked NPC asset (or with an NPC asset that has an ID mismatch), no NPC will spawn at runtime and the Object will be invisibly present in the world.

Resolution: confirm the NPC Object's ID field matches the ID referenced in the NPC asset configuration. NPC asset configuration is covered in the NPC authoring article; this guide documents only the Object sub-type field.

Pitfall 7: Structure with Eligible_For_Pull false cannot be cleaned up

Eligible_For_Pull false (the default) means a structure cannot be salvaged. On a server where player bases accumulate over time, non-pullable structures become permanent clutter if the player who placed them is banned or leaves the server. This is a server administration concern, not a bug, but it is a frequent design oversight.

Resolution: for standard player-built structures, set Eligible_For_Pull true. For event structures or admin-placed permanent structures, the default false is appropriate.

---

Per-type Unity prefab requirements

Each asset category has different requirements for the Unity prefab structure. The table below summarizes the mandatory components for each.

Category	Required components	Optional but recommended
Object (Small, Medium, Large)	MeshRenderer, MeshFilter, Collider (any type)	NavMeshObstacle (Large only), AudioSource (for interactive binary-state objects)
Object (Decal)	MeshRenderer (quad or plane), MeshFilter, Decal material assigned	No collider — Decal objects are non-physical
Object (NPC)	No renderer (empty GameObject)	AudioSource (for NPC ambient audio)
Object (Resource)	MeshRenderer, MeshFilter, Collider	LOD Group (for performance with many trees/ore veins in scene)
Structure	MeshRenderer, MeshFilter, Collider sized to grid cell	AudioSource (construction sound)
Barricade	MeshRenderer, MeshFilter, Collider	AudioSource (placement sound), Animator (for animated barricades like powered generators)

---

Asset folder layout

The 57 Studios™ cohort convention for Objects, Structures, and Barricades follows the same folder pattern as other mod asset types. Each asset gets its own named subfolder inside the mod's Bundles/ directory.

MyModWorkshopContent/
├── Bundles/
│   ├── Objects/
│   │   └── AbandonedMailbox/
│   │       ├── AbandonedMailbox.dat
│   │       ├── English.dat
│   │       └── AbandonedMailbox.unity3d
│   ├── Structures/
│   │   └── WoodWall/
│   │       ├── WoodWall.dat
│   │       ├── English.dat
│   │       └── WoodWall.unity3d
│   └── Barricades/
│       └── CustomSandbag/
│           ├── CustomSandbag.dat
│           ├── English.dat
│           └── CustomSandbag.unity3d

The category subfolder name (Objects/, Structures/, Barricades/) must match the convention; the Unturned™ asset loader uses the directory path to determine which asset category resolver to apply.

---

Testing checklist

The following checklist covers the minimum verification steps for each asset category before Steam Workshop submission.

Object testing checklist

• [ ] Asset loads in the level editor without error in the Unity console.
• [ ] Asset appears in the level editor's asset picker under the correct category.
• [ ] Asset can be placed in the level editor.
• [ ] Placed asset has correct visual appearance (materials, scale, orientation).
• [ ] Collision mesh matches the visual mesh (no visible gaps, no oversized invisible collision).
• [ ] For Large sub-type: zombies pathfind around the asset, not through it.
• [ ] For Small sub-type: zombies do not hard-stop against the asset's invisible collision perimeter.
• [ ] For Decal sub-type: decal projects onto underlying geometry without z-fighting.
• [ ] For Binary_State interactability: toggling the object changes its visual and collision state correctly.
• [ ] English.dat Name and Hint display correctly in-game tooltip.

Structure testing checklist

• [ ] Structure item spawns in inventory via @give <ID>.
• [ ] Structure item can be equipped and placed.
• [ ] Placement distance matches the Range field.
• [ ] Structure snaps to the correct grid position for its Type (wall, floor, etc.).
• [ ] Adjacent structure placements are not blocked by oversized collision.
• [ ] Structure can be damaged to Health 0 and destroys correctly.
• [ ] For Eligible_For_Pull true: salvage tool removes the structure without destroying it.
• [ ] Crafting recipe produces the structure item from the correct materials.
• [ ] English.dat Name and Description display correctly in inventory and tooltip.

Barricade testing checklist

• [ ] Barricade item spawns in inventory via @give <ID>.
• [ ] Barricade item can be placed on all surfaces enabled by can-place-on flags.
• [ ] Barricade item cannot be placed on surfaces not enabled by can-place-on flags.
• [ ] Placed barricade has correct visual appearance and orientation.
• [ ] Barricade collision matches visual mesh.
• [ ] Barricade can be damaged to Health 0 and destroys correctly.
• [ ] For Interactability Storage: opening the barricade shows the correct grid dimensions and persists stored items.
• [ ] For Interactability Bed: sleeping bag spawn-point registration works correctly.
• [ ] For Can_Place_On_Vehicle: barricade placed on a moving vehicle does not exhibit physics jitter.
• [ ] English.dat Name and Description display correctly.

---

Frequently asked questions

What is the difference between a Barricade and a Structure if both are player-placed?

The difference is grid behavior and surface requirements. Structures snap to a 3 m × 3 m architectural grid and require adjacent compatible elements to validate placement — a Wall must sit on a Floor or adjacent to a Pillar. Barricades are placed freely without grid snapping; the player aims at a valid surface and the engine places the barricade at the cursor position. Think of Structures as architectural components and Barricades as deployable props.

Can an Object be destroyed by players in-game?

By default, Objects cannot be damaged by players. They are map-baked elements. The exception is Objects with explicit interactability configurations that allow state changes (e.g., a door that can be opened). Object destruction by players is not a supported interaction in vanilla Unturned™ without modifying game scripts.

My Structure wall is placed correctly but adjacent walls cannot snap to it. What is wrong?

The most likely cause is a collision mesh that extends beyond the 3 m × 3 m grid cell boundary, preventing adjacent cells from being valid placement targets. Open the prefab in Unity, inspect the collider, and confirm it does not exceed the grid cell dimensions. Add a 0.01 m inset margin on shared edges.

How do I make a barricade that can only be placed inside a player base (on structure floors), not on open terrain?

Omit Can_Place_On_Ground from the .dat and include only Can_Place_On_Floor. The engine will reject placement attempts on terrain and accept them only on structure floor panels.

Can I have a Barricade that provides storage and also functions as a sentry turret?

No. The Interactability field accepts a single value; Storage and Sentry cannot be combined on one Barricade. Author two separate Barricades — one for storage and one for sentry functionality — and present them as a paired mod set.

What is the maximum Health value for a Structure or Barricade?

The Health field is a uint16, which has a maximum value of 65535. This is effectively indestructible in normal gameplay, as the highest-damage explosives in vanilla Unturned™ deal well under 1000 damage per hit. A Structure or Barricade with Health 65535 should be treated as permanent for gameplay purposes.

Why does my Object appear in the level editor but not in-game after the map is played?

The most common cause is that the Object's master bundle was not included in the map's content loading list. Confirm the .unity3d bundle file is in the correct Bundles/ directory and that the map's Config.json references the mod ID. The second possible cause is an ID mismatch between the .dat file and the placed Object reference stored in the level data.

Can I make a Barricade that automatically respawns after being destroyed?

Barricade respawning is not configurable via the .dat file. Barricades are runtime-placed by players and are not automatically respawned by the engine. If you need automatic respawning (e.g., for a server event prop), the recommended approach is to author a server-side script (using the Rocket plugin framework or OpenMod) that listens for the barricade destroyed event and re-spawns it via the API.

What does the Proof_Explosion flag do on a Barricade?

Proof_Explosion makes the barricade immune to explosion-type damage, meaning grenades, rocket launchers, and demolition charges deal zero damage to it. The barricade can still be destroyed by melee, gunfire, or other non-explosion damage types. Use this for barricades that should not be one-shotted by explosives but should still be destroyable by sustained small-arms fire.

How do I make a Barricade mount a sign with custom text?

Set Interactability Sign on the Barricade. Players who interact with the placed sign will be prompted to enter text. The entered text is stored server-side and displayed on the sign's surface. For the text to display on the 3D mesh, the prefab must have a TextMeshPro or legacy Text component at a named child GameObject that the engine's sign script references. Consult the Smartly Dressed Games modding documentation at docs.smartlydressedgames.com for the required child GameObject naming convention.

My Resource-type Object does not yield materials when harvested. What is wrong?

A Resource Object sub-type must be paired with a Resource Asset .dat that defines the harvest yield. The Object sub-type marks the placement position; the Resource Asset defines what the player receives. Confirm the Resource Asset .dat exists, has the correct ID, and is in the correct Bundles/Resources/ directory. See Resource Asset (the previous article in this section) for the Resource Asset .dat authoring workflow.

Can a Structure or Barricade be placed by the server (not by a player)?

Yes, using server-side scripting. The Unturned™ server API exposes StructureManager.dropStructure() and BarricadeManager.dropBarricade() methods that spawn placed instances without requiring a player placement action. This is used for event servers, custom game modes, and admin-placed content. The .dat configuration is identical regardless of whether the placement originates from a player or from the server API.

---

Appendix A: Complete Object .dat field reference

The following table covers every documented Object .dat field including fields not covered in the main article.

Field	Type	Required	Notes
ID	uint16	Yes	Asset ID.
GUID	uint128	Yes	Globally unique identifier.
Type	enum	Yes	Object
Object_Type	enum	Yes	Small, Medium, Large, Decal, NPC, Resource
Name	string	Yes	Internal name.
Interactability	enum	No	None, Binary_State, Note
Is_Binary_State_Collision	flag	No	Different collision per binary state.
Binary_State_0	string	No	Label for state 0 (e.g., Closed).
Binary_State_1	string	No	Label for state 1 (e.g., Open).
Binary_State_Reset	float	No	Seconds before automatic state reset. 0 = no reset.
Allow_Structures	flag	No	Players can build on this object.
Foliage_Instancing	flag	No	GPU instancing for high-repeat objects.
Use_Water_Height_Transparent_Sort	flag	No	Water transparency sorting.
LODs	uint8	No	Number of LOD levels. Requires matching LOD child GameObjects in the prefab.
LOD_0_Distance	float	No	Distance at which LOD 0 transitions to LOD 1.
Is_Gore	flag	No	When present, the object respects the game's gore visibility setting.
Christmas_Redirect	uint16	No	When present, during the Christmas seasonal event this object is replaced by the specified asset ID.
Halloween_Redirect	uint16	No	Same as Christmas_Redirect for the Halloween event.

---

Appendix B: Complete Structure .dat field reference

Field	Type	Required	Notes
ID	uint16	Yes	Asset ID.
GUID	uint128	Yes	Globally unique identifier.
Type	enum	Yes	First occurrence: Structure (asset category).
Name	string	Yes	Internal name.
Rarity	enum	No	Inventory rarity.
Slot	enum	Yes	Structure
Size_X / Size_Y	uint8	Yes	Inventory footprint.
Type	enum	Yes	Second occurrence: Wall, Floor, Roof, Post, Pillar, Rampart
Health	uint16	Yes	Hit points.
Range	float	Yes	Placement range in meters.
Eligible_For_Pull	bool	No	true = salvageable. Default false.
Armor_Tier	enum	No	LowCaliber, HighCaliber
Explosion	uint16	No	Explosion asset ID on destruction.
Proof_Explosion	flag	No	Immune to explosion damage.
Unpickupable	flag	No	Cannot be salvaged.
Unrepairable	flag	No	Cannot be repaired.
Blueprints	uint8	No	Number of crafting blueprints.
Blueprint_N_Type	enum	No	Blueprint type per index N.
Blueprint_N_Supplies	uint8	No	Input ingredient count per blueprint.
Blueprint_N_Supply_N_ID	uint16	No	Input ingredient item ID.
Blueprint_N_Supply_N_Amount	uint8	No	Input ingredient quantity.
Blueprint_N_Product	uint16	No	Output item ID.
Blueprint_N_Products	uint8	No	Output quantity.

---

Appendix C: Complete Barricade .dat field reference

Field	Type	Required	Notes
ID	uint16	Yes	Asset ID.
GUID	uint128	Yes	Globally unique identifier.
Type	enum	Yes	Barricade
Name	string	Yes	Internal name.
Rarity	enum	No	Inventory rarity.
Slot	enum	Yes	Barricade
Size_X / Size_Y	uint8	Yes	Inventory footprint.
Health	uint16	Yes	Hit points.
Range	float	Yes	Placement range in meters.
Can_Place_On_Ground	flag	No	Placement on terrain.
Can_Place_On_Floor	flag	No	Placement on structure floors.
Can_Place_On_Ceiling	flag	No	Placement on ceilings.
Can_Place_On_Wall	flag	No	Placement on structure walls.
Can_Place_On_Vehicle	flag	No	Placement on vehicle surfaces.
Unpickupable	flag	No	Cannot be salvaged.
Unsalvageable	flag	No	Salvage yields no materials.
Unrepairable	flag	No	Cannot be repaired.
Invulnerable	flag	No	Cannot be damaged at all.
Explosion	uint16	No	Explosion asset on destruction.
Proof_Explosion	flag	No	Immune to explosion damage.
Interactability	enum	No	See Interactability fields table.
Interactability_Health	uint16	No	Fuel / charge capacity.
Interactability_Text	string	No	Note text content.
Interactability_Delay	float	No	Interaction trigger delay.
Interactability_Reset	float	No	Auto-reset timer.
Interactability_Storage_X / _Y	uint8	No	Storage grid dimensions.
Interactability_Locked	flag	No	Starts in locked state.
Blueprints	uint8	No	Number of crafting blueprints.
Blueprint_N_*	—	No	Same pattern as Structure blueprints.

---

Cross-references

• Resource Asset — the preceding article; covers Resource Object sub-type yield configuration and respawn timers.
• Project Folder Structure and GUIDs — how to generate GUIDs, how to lay out the mod folder, and how to configure the Unity project for modding.
• Master Bundle Export — how to package Object, Structure, and Barricade prefabs into .unity3d bundles.
• Custom Map Creation: Project Setup — the next article; covers placing Object assets in the level editor as map decoration.
• Gun Mod Tutorial — shares the Unity prefab authoring workflow used for Structure and Barricade prefabs.
• Smartly Dressed Games Modding Documentation — the official modding reference. The Objects, Structures, and Barricades pages document additional fields not covered here.
• Unturned on Steam — the game's Steam page.

---

Document history

Version	Date	Author	Notes
1.0	2025-05-18	57 Studios™	Initial publication. Object sub-types, Structure Type enum, Barricade can-place-on flags, collision pitfalls, and full field references.