Structure Asset Reference

Intermediate40-60 minutesWindowsNotepad++Unity Editor

Structure assets are the architectural building blocks of Unturned™ base-building. A structure asset defines any player-constructable element that snaps to the 3-meter structural grid - walls, floors, roofs, pillars, posts, and ramparts. The ItemStructureAsset class, which inherits from the ItemPlaceableAsset base class, provides the field surface that controls placement validation, grid snapping, armor behavior, damage resistance, salvage mechanics, and audiovisual feedback for every structure piece in the game. Structures differ fundamentally from barricades in that they require the structural grid for placement validation; a wall cannot be placed without an adjacent floor or pillar, and a roof cannot be placed without supporting walls beneath it.

57 Studios™ has documented and validated the complete structure asset .dat field surface across the Unturned™ modding community. This article covers every structure-specific field documented in the official Smartly Dressed Games modding reference, the Construct enum that determines grid snapping behavior and placement validation, the Armor_Tier system that controls damage resistance, the Terrain_Test_Height field for elevated floor placement, the Foliage_Cut_Radius field that governs vegetation removal around placed structures, the Requires_Pillars flag for wall placement constraints, and the salvage and repair configuration surface. Two worked examples - a wooden wall panel and a metal floor panel - demonstrate the complete .dat authoring pattern.

Documentation source: This article references the official Smartly Dressed Games modding documentation for field definitions and game behavior, cross-referenced against shipped game files in Bundles\Items\Structures\*\*.dat. Community-validated notes are marked where the official documentation is silent on a detail.

Who this article is for

This article is written for Unturned™ mod authors who have completed at least one item mod of another type and are familiar with the master bundle pipeline and .dat authoring workflow. Mod authors who have read Barricade Asset Reference will recognize shared fields from the ItemPlaceableAsset base class; this article focuses on the fields that are unique to the ItemStructureAsset subclass and on the structural grid system that distinguishes structures from barricades. If you are new to Unturned™ modding, start with Project Folder Structure and GUIDs and Item Asset Anatomy before returning here. The companion guide Objects, Structures, and Barricades provides the three-category distinction that frames the structure asset type.

What you'll learn

• The complete ItemStructureAsset field set including grid placement, armor, foliage, salvage, and audio fields
• The Construct enum controlling grid snapping behavior (Floor, Wall, Roof, Pillar, Post, Rampart, Floor_Poly, Roof_Poly)
• How structures differ from barricades in placement validation, grid snapping, and the save system
• The Requires_Pillars field and its effect on wall placement validation
• The Terrain_Test_Height field for elevated floor placement above terrain
• The Foliage_Cut_Radius field and vegetation removal behavior
• The interaction between Armor_Tier and the gameplay config multipliers
• The salvage and repair configuration surface including Eligible_For_Pull on structures
• Worked .dat examples for wall and floor structure types
• Full diagnostic troubleshooting table for common structure authoring issues

How the structure system works

The Unturned™ structure runtime is driven by the ItemStructureAsset class and the StructureManager server-side system. The structural grid is a fixed 3-meter grid that exists world-space regardless of whether any structures are placed. When a player equips a structure item and presses the build key, the engine reads the .dat configuration, validates the target position against the structural grid, checks that the required adjacent structure elements exist (a wall requires a floor or pillars, a roof requires walls, and so on), confirms the placement is within Range distance, and spawns the structure prefab as a world entity snapped to the nearest grid cell.

The structural grid enforces that every placed structure occupies exactly one grid cell. A wall occupies one vertical cell; a floor occupies one horizontal cell; a roof occupies one horizontal cell at a configurable height offset. The grid is continuous across the entire playable world space; there is no limit on cell count other than the server's performance capacity.

How structures differ from barricades

The following table summarizes the key behavioral differences between structures and barricades. Both inherit from ItemPlaceableAsset and share many base-class fields, but their runtime behavior diverges substantially.

Dimension	Structures	Barricades
Placement system	Grid-snapped to 3m cells	Free placement on valid surfaces
Adjacent requirement	Many Construct types require adjacent pieces	No adjacency requirement
Save persistence	Server save file grid-referenced	Server save file world-position-referenced
Salvage mechanic	Uses Eligible_For_Pull flag	Uses Unpickupable flag
Default inventory slot	Structure	Barricade
Primary class	ItemStructureAsset	ItemBarricadeAsset
Construct / Build enum	Grid behavior classification	Functional behavior classification
Foliage removal	Automatic via Foliage_Cut_Radius	No foliage interaction
Terrain height test	Supported via Terrain_Test_Height	Not applicable

The Construct enum

The Construct field is the primary classification field on a structure asset. It controls grid snapping, placement validation, and how other structure pieces can snap to it. The Construct enum accepts the following values.

Construct value	Grid position	Placement validation rules	Typical geometry
Floor	Horizontal grid cell	Requires a valid ground surface or adjacent Floor/Pillar below	Flat panel, 3m x 3m
Floor_Poly	Horizontal grid cell	Same as Floor but supports non-rectangular geometry	Angled or irregular floor shapes
Pillar	Vertical grid edge	Snap to pillar positions at wall edge intersections	Thin vertical column
Post	Vertical grid corner	Snap to corner positions independent of adjacent pieces	Square column at grid corner
Rampart	Vertical grid cell (wall position)	Same as Wall but with angled/stepped geometry	Angled parapet wall
Roof	Horizontal grid cell (elevated)	Requires Walls or Pillars below	Angled or flat roof panel
Roof_Poly	Horizontal grid cell (elevated)	Same as Roof but supports non-rectangular geometry	Angled roof with irregular shape
Wall	Vertical grid cell	Requires a Floor below or Pillars on both vertical edges	Flat vertical panel, 3m x 3m

The Floor_Poly and Roof_Poly values support irregular (non-rectangular) mesh geometry for the floor or roof surface. They use the same grid validation rules as their standard counterparts but allow the mesh to extend beyond the rectangular grid footprint where the design requires. Most standard structures should use Floor and Roof; the _Poly variants are for specialized architectural shapes such as hexagonal or triangular building modules.

File and folder structure

A complete structure mod item requires the following files in the standard Unturned™ mod layout:

Workshop/Content/304930/<modID>/
├── Bundles/
│   └── <BundleName>.unity3d              ← master bundle containing the structure prefab
└── Items/
    └── MyStructure/
        ├── MyStructure.dat               ← primary structure configuration
        └── English.dat                   ← display name and description

The folder name, the .dat filename stem, and the internal Name field should all match. The item folder goes under Items/ following standard item mod folder conventions. Structure items are classified in the inventory as Slot Structure items, not as building materials.

Complete structure .dat field reference

Identity and shared item fields

Every structure item requires the standard identity block shared across all item asset types. The structure-specific conventions are noted in the table.

Field	Type	Example	Required	Purpose
ID	uint16	50400	Yes	Numeric item ID. Must be unique across all loaded mods. Use IDs in the 50000+ range.
GUID	uint128 hex	d4e5f6a7b8c94a0b1c2d3e4f5a6b7c8d	Yes	128-bit globally unique identifier. Generate a new GUID for every new structure asset.
Type	enum	Structure	Yes	Must be Structure for structure assets. When intending to use a child class that requires a different enumerator, refer to that class's documentation.
Useable	enum	Structure	Yes	Must be Structure for structure assets. This field controls which Useable class the engine instantiates.
Construct	enum	Wall	Yes	The structure's grid snapping classification. Must be one of: Floor, Floor_Poly, Pillar, Post, Rampart, Roof, Roof_Poly, Wall.
Name	string	CustomWoodWall	Yes	Internal name. Used in console commands and cross-references.
Rarity	enum	Common	No	Controls the inventory highlight color. Defaults to Common.
Slot	enum	Structure	Yes	Inventory slot. Must be Structure for structure items.
Size_X	uint8	1	Yes	Width in inventory grid cells. Structure items are typically 1x1.
Size_Y	uint8	1	Yes	Height in inventory grid cells. Structure items are typically 1x1.
Model	string	CustomWallPrefab	No	Override the prefab name if it differs from the Name field.
InventoryAudio	master bundle pointer	-	No	The audio clip played when the item is moved in inventory. Defaults are determined by size and naming conventions.

Placement and grid fields

The placement fields control the grid snapping behavior, placement distance, and terrain interaction for the structure.

Field	Type	Default	Purpose
Range	float	4.0	In meters, the maximum distance away the structure can be placed from the player. Measured from the player's camera or chest position.
Terrain_Test_Height	float	10.0	Length of the raycast downward from the pivot to check if the floor is above terrain. This is the maximum distance a floor can be placed above terrain, in meters. For elevated bases built on pillars, set this to at least the intended base height above ground.
Foliage_Cut_Radius	float	6.0	In meters, the radius around the placed structure where foliage (grass, small plants, bushes) is removed. Higher values clear a larger area around the structure. A value of 0 disables foliage removal.
Requires_Pillars	bool	true	Whether a valid wall placement requires pillars. If true, two pillars are required on each vertical edge of the wall for a valid placement. Set to false for walls that should be placeable without pillars (such as the lower-floor walls of a foundation-level structure).

Health and armor fields

Field	Type	Default	Purpose
Health	uint16	0	Total health value. A structure with Health 0 is destroyed on first damage event. Typical starting values: wood walls 500 HP, metal walls 1800 HP, armored plate walls 3500 HP.
Armor_Tier	enum	Low	Structure armor tier. Values: Low, High. The armor tier is a multiplier on damage received. Low-tier structures take 100% of incoming damage by default. High-tier structures take 50% of incoming damage by default. Both multipliers are configurable in the gameplay config file. Defaults to Low-tier, except when the structure's name contains the word Metal or Brick.
Can_Be_Damaged	bool	true	If true, this structure can be damaged by weapons, explosives, melee, and zombie attacks. Set to false for indestructible admin structures or decorative set-pieces.
Proof_Explosion	flag	not set	When present, the structure is immune to area-of-effect explosive damage.
Vulnerable	flag	not set	When present, the structure can be damaged by lower-power weapons that do not have the Invulnerable flag.
Can_Zombies_Target	bool	true	If true, this structure is eligible for zombie detection and attack when zombies are stuck. Set to false for structures that should never be attacked by zombie AI (such as extremely high platforms that zombies should pathfind around rather than through).
Explosion	GUID or uint16	-	The GUID or legacy ID of the EffectAsset to play when the structure is destroyed.

Salvage and pickup fields

Field	Type	Default	Purpose
Salvage_Duration_Multiplier	float	1.0	Multiplier on how long it takes to salvage this structure. Larger values increase salvage time.
Unpickupable	flag	not set	When present, disables the ability to pick up a placed structure. The structure is permanent once placed.
Unrepairable	flag	not set	When present, the structure cannot be repaired by a MeleeAsset with the RepairTool flag.
Unsalvageable	flag	not set	When present, salvaging a damaged structure yields no partial resources.
Unsaveable	flag	not set	When present, the structure is excluded from being saved to the server save file and will not persist across restarts.

Visual and audio fields

Field	Type	Default	Purpose
PlacementAudioClip	master bundle pointer	-	The AudioClip to play when the structure is placed. Provides placement audio feedback to the player and nearby players.
PlacementPreviewPrefab	master bundle pointer	-	Overrides the placement preview model spawned when the structure item is held.
Has_Clip_Prefab	bool	true	Whether the structure has a Clip.prefab for server-side collision. If the structure should use the same prefab on the server as on the client, set to false. Most official content uses Has_Clip_Prefab false.

Pooling field

Field	Type	Default	Purpose
Eligible_For_Pooling	bool	true	If true, this structure is eligible for object pooling. Some structures may not reset properly when pooling is enabled. Defaults to true.

Worked example: wooden wall panel

The following .dat file defines a wooden wall structure panel. This is a Construct Wall type with standard wood-tier health and grid snapping behavior. It requires adjacent floors or pillars for placement validation (the Requires_Pillars true default) and includes a crafting blueprint that consumes planks.

ID 50400
GUID d4e5f6a7b8c94a0b1c2d3e4f5a6b7c8d
Type Structure
Useable Structure
Construct Wall
Name CustomWoodWall
Rarity Common
Slot Structure
Size_X 1
Size_Y 1

Health 500
Range 4.0
Terrain_Test_Height 10.0
Foliage_Cut_Radius 6.0
Requires_Pillars true

Armor_Tier Low
Can_Be_Damaged true
Can_Zombies_Target true

Eligible_For_Pooling true
Salvage_Duration_Multiplier 1.0

Has_Clip_Prefab false

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

Companion English.dat:

Name Wooden Wall
Description A standard wooden wall panel for base construction. Snaps to the structural grid. Requires adjacent floors or pillars for placement.

Worked example: metal floor panel

The following .dat file defines a metal floor structure panel. This is a Construct Floor type with higher health than wood, high-tier armor, and a larger foliage cut radius.

ID 50401
GUID e5f6a7b8c9d04a1b2c3d4e5f6a7b8c9d
Type Structure
Useable Structure
Construct Floor
Name CustomMetalFloor
Rarity Common
Slot Structure
Size_X 1
Size_Y 1

Health 1800
Range 5.0
Terrain_Test_Height 12.0
Foliage_Cut_Radius 8.0

Armor_Tier High
Can_Be_Damaged true
Can_Zombies_Target true
Proof_Explosion

Eligible_For_Pooling true
Salvage_Duration_Multiplier 1.5

Has_Clip_Prefab false

Blueprints 1
Blueprint_0_Type Craft
Blueprint_0_Supplies 2
Blueprint_0_Supply_0_ID 50101
Blueprint_0_Supply_0_Amount 3
Blueprint_0_Supply_1_ID 50102
Blueprint_0_Supply_1_Amount 2
Blueprint_0_Product 50401
Blueprint_0_Products 1

Companion English.dat:

Name Metal Floor
Description A reinforced metal floor panel for base construction. High-tier armor provides 50% damage reduction. Requires metal sheets and nails to craft.

Worked example: roof panel

The following .dat file defines a roof structure panel with angled geometry. Roofs require walls or pillars below them on the structural grid for valid placement.

ID 50402
GUID f6a7b8c9d0e14a2b3c4d5e6f7a8b9c0d
Type Structure
Useable Structure
Construct Roof
Name CustomWoodRoof
Rarity Common
Slot Structure
Size_X 1
Size_Y 1

Health 400
Range 4.0
Terrain_Test_Height 10.0
Foliage_Cut_Radius 6.0

Armor_Tier Low
Can_Be_Damaged true
Can_Zombies_Target true

Eligible_For_Pooling true
Salvage_Duration_Multiplier 1.0

Has_Clip_Prefab false

Blueprints 1
Blueprint_0_Type Craft
Blueprint_0_Supplies 1
Blueprint_0_Supply_0_ID 50100
Blueprint_0_Supply_0_Amount 4
Blueprint_0_Product 50402
Blueprint_0_Products 1

Companion English.dat:

Name Wooden Roof
Description A wooden roof panel. Must be placed above walls or pillars on the structural grid. Provides overhead cover from rain and aerial threats.

Prefab structure for structures

The Unity prefab for a structure requires a specific component layout to function correctly with the structural grid system. The minimum cohort-validated hierarchy is:

MyStructurePrefab (root GameObject)
├── Body (MeshRenderer + MeshFilter - structure visual mesh)
├── Collider (BoxCollider sized to exactly 3m × 3m grid cell)
└── AudioSource (placed at root for placement/construction audio)

Component requirements by Construct type

Construct type	Collider requirements	Mesh positioning	Additional components
Wall	BoxCollider, 3m × 3m × 0.1m (thin)	Center at grid cell origin	AudioSource for construction sound
Floor	BoxCollider, 3m × 3m × 0.1m (thin)	Bottom face at grid cell floor	AudioSource
Roof	BoxCollider, 3m × 3m × 0.1m (thin)	Bottom face at grid cell ceiling height	AudioSource
Pillar	BoxCollider or CapsuleCollider, 0.5m × 0.5m × 3m	Centered on vertical grid edge	AudioSource
Post	BoxCollider, 0.5m × 0.5m × 3m	Centered on vertical grid corner	AudioSource
Rampart	BoxCollider sized to 3m × 3m wall face area with height stepped	Center at grid cell origin	AudioSource
Floor_Poly	MeshCollider (convex) matching irregular shape	Snapped to grid cell center	AudioSource
Roof_Poly	MeshCollider (convex) matching irregular shape	Snapped to grid cell center	AudioSource

Grid cell sizing conventions

Every structure prefab must fit within the 3-meter grid cell that the engine uses for placement validation. The cell origin is the world-space position of the prefab root. The cell extends 1.5 meters in each direction from the origin along the horizontal axes and 3 meters along the vertical axis. A wall prefab's pivot must be at the bottom center of the cell; a floor prefab's pivot must be at the top-left corner of the cell in the engine's coordinate convention. The easiest way to ensure correct grid alignment is to position the prefab pivot at the bottom center of its bounding box and to set the prefab root transform to (0, 0, 0) in the Unity prefab editor before export.

┌──────────────────────────────────┐
│  Grid cell layout (top view)     │
│                                  │
│      3.0 m                       │
│  ┌────────────┐                  │
│  │            │                  │
│  │  Wall cell │  3.0 m           │
│  │            │                  │
│  │  (pivot)   │                  │
│  └────────────┘                  │
│       ↑                         │
│  Prefab root position            │
│  at bottom center of cell        │
└──────────────────────────────────┘

A structure whose collision mesh extends beyond the 3m grid cell boundary will prevent adjacent structure placement and produce the "collision extends outside grid cell" pitfall documented in the companion guide Objects, Structures, and Barricades.

Structure grid validation rules by Construct type

The structural grid uses a validation system that enforces architectural consistency. Each Construct type has specific adjacency requirements that must be satisfied for a placement to succeed. The table below documents every Construct type's validation rules.

Construct type	Requires below	Requires adjacent	Requires above	Notes
Floor	Ground / another Floor / Pillar	-	-	The base grid unit. First floor placed on terrain establishes grid origin.
Floor_Poly	Ground / another Floor / Pillar	-	-	Same validation as Floor; supports irregular mesh geometry.
Wall	Floor / another Wall	Pillars (if Requires_Pillars true)	Roof (optional)	Standard vertical enclosure. Cannot float without floor or lower wall.
Pillar	Floor / ground / another Pillar	Wall edge	Wall above / Roof	Vertical edge support. Does not occupy full cell volume.
Post	Floor / ground / another Post	-	Post above / Roof	Corner column. Independent of wall placement.
Rampart	Floor / Wall	Same as Wall	-	Angled defensive wall element. Placement same as Wall.
Roof	Wall / Pillar	-	-	Requires supporting vertical elements. Cannot float.
Roof_Poly	Wall / Pillar	-	-	Same validation as Roof; supports irregular mesh geometry.

As shown in the flowchart above, the placement validation logic depends on the Construct type and the presence of adjacent structural pieces. Understanding the validation rules before authoring a structure prefab prevents placement failures that are not signaled by error messages - the engine silently rejects invalid placements with no console output.

Diagnostic table

Symptom	Most likely cause	Resolution
Structure cannot be placed anywhere	Construct type not matching the target grid position	Confirm you are attempting to place the correct Construct type at a valid grid position
Wall cannot be placed on ground floor	Requires_Pillars true with no pillars placed	Place pillars at both wall edges first, or set Requires_Pillars false
Floor cannot be placed above terrain	Terrain below the pivot exceeds Terrain_Test_Height distance	Increase Terrain_Test_Height to cover the intended elevation
Structure appears but sinks below terrain	Offset not set or set incorrectly	Set an Offset value to raise the structure above the ground surface
No foliage cleared around placed structure	Foliage_Cut_Radius is 0	Set Foliage_Cut_Radius to a positive value (6.0 is the standard starting point)
Structure invisible when placed	Prefab reference broken or Has_Clip_Prefab true with no clip prefab	Set Has_Clip_Prefab false or provide a clip prefab in the bundle
Structure does not save across restarts	Unsaveable flag present	Remove the Unsaveable flag
Structure cannot be salvaged	Eligible_For_Pull is false (default)	Set Eligible_For_Pull true on the ItemPlaceableAsset base fields if salvage should be allowed
Structure takes too much damage	Armor_Tier is Low when it should be High	Change Armor_Tier to High, which applies the 50% damage multiplier
Structure is immune to damage	Can_Be_Damaged false	Set Can_Be_Damaged true
Structure destroyed by single explosion	Proof_Explosion flag missing	Add Proof_Explosion
Zombies ignore the structure	Can_Zombies_Target false	Set Can_Zombies_Target true or add a NavMeshObstacle component to the prefab
Structure cannot be placed next to another structure	Collision mesh extends beyond the 3m grid cell	Resize the collision mesh to fit exactly within the grid cell boundary
Placement preview shows wrong model	PlacementPreviewPrefab missing or wrong	Correct or set PlacementPreviewPrefab in the .dat
No sound on placement	PlacementAudioClip missing	Set PlacementAudioClip to a valid audio clip reference in the master bundle

Advanced considerations

Elevated base design with Terrain_Test_Height

The Terrain_Test_Height field controls the maximum elevation at which a floor can be placed above terrain. For sky bases or elevated platforms, set this to 50 or higher. The engine will cast a ray downward from the floor's pivot position up to Terrain_Test_Height distance. If the ray does not hit terrain within that distance, the floor placement is rejected. For bases intended to float at extreme heights (e.g., sky bases above the standard build height), set Terrain_Test_Height to 254 - the practical maximum for most Unturned™ maps.

Structural armor tier and gameplay config interaction

The Armor_Tier field on a structure asset is a declaration of intent, not an absolute value. The actual damage multiplier is determined by the server's gameplay config file (Config/Gameplay.config). The default configuration applies 1.0 multiplier to low-tier structures and 0.5 to high-tier structures. A server administrator can change these multipliers globally. A structure authored as Armor_Tier High on a server where the high-tier multiplier has been changed to 1.0 (equal to low-tier) will receive no damage reduction benefit. The cohort recommendation is to design structure health values assuming the default multipliers, with a note in the mod's documentation that server administrators can adjust armor effectiveness.

Multi-material structures and Require_Pillars behavior

When Requires_Pillars is true, a wall must have a pillar on both its left and right vertical edges for placement to succeed. This means the first wall segment in a base requires at least two pillars - one at each edge - before the wall can be placed between them. For initial base construction, many modders set Requires_Pillars false on their lower-floor walls to allow a simpler foundation-to-wall sequence: place the first floor, then place walls directly on it without pillars. Upper-floor walls can use the default Requires_Pillars true to enforce structural consistency on higher levels.

Structure health balancing for PvP and PvE contexts

Structure health requirements differ dramatically between PvP and PvE servers. On a PvE survival server, a wood wall with 500 HP is a meaningful barrier that requires sustained effort to break through with hand tools. On a PvP raiding server, the same 500 HP wall is destroyed in seconds by two players with axes. The cohort recommendation for PvP-balanced structures is to use metal-tier or armored-tier health values as the baseline and to provide the Proof_Explosion flag on all base-perimeter pieces. If the target server type is unknown, author structure health at the metal tier and include a server-configurable scaling note in the mod's documentation.

### What is the maximum Range value for structure placement?

The Range field accepts float values up to the limits of the float type, but practical range values for structure placement are constrained by the single-player render distance and server Structure_Range config settings. Values above 10.0 allow placing structures beyond the player's immediate visual range, which can produce placement failures that appear random to the player. The cohort recommendation is to keep Range between 3.0 and 6.0 for standard structures and to use 8.0 only for specialized long-reach building tools.

Does Foliage_Cut_Radius affect grass regrowth?

Foliage_Cut_Radius removes foliage at the time of placement only. The removed foliage does not grow back within the structure's lifetime. If the structure is destroyed or salvaged, the foliage does not automatically regrow; it regenerates according to the server's foliage respawn timer (typically tied to the chunk's regeneration cycle). The cut radius is a one-time event, not a persistent suppression zone.

Can I make a structure that is placeable only on water?

There is no water-placement-specific field on ItemStructureAsset. Structures require a solid surface for the terrain test raycast. For water-level structures, the recommended approach is to place a solid platform structure at a depth within Terrain_Test_Height range and then place additional structures on that platform. A dedicated water-foundation mod would use a Construct Floor placed at water level with a Range value appropriate for shoreline access.

How does the engine handle overlapping structures from different mods?

The Unturned™ engine does not check mod origin when validating structure placement. If two mods place structures at the same grid cell coordinate, the engine places both structures at the same position, producing visual z-fighting and collision overlap. This is not prevented by the engine. Mod authors who produce structure packs should coordinate grid cell occupancy within their mod to avoid self-overlap. Cross-mod overlap is the responsibility of the server administrator to manage through mod selection.

Advanced considerations

Structure fill-order and grid-origin establishment

The first structure piece placed in a world location establishes the grid origin for that area. The grid origin is locked to the world-space position of the first piece; all subsequent pieces snap to positions relative to that origin. If the first piece is a floor at world coordinate (100, 0, 100), all subsequent walls, floors, and roofs in that base snap to the grid whose origin is (100, 0, 100) with 3-meter spacing. This means two bases built close together on independent grid origins will have misaligned grids. The engine does not merge or reconcile overlapping grids; each base retains its own origin throughout the server session.

Structure migration between mod ID changes

When a structure asset's ID changes after existing structures have been placed on a live server, the placed structure instances in the server save file continue to reference the old ID. The engine will not find an asset matching the old ID and will fail to load the placed structure on the next server start. The structure will appear in the save file as a dead reference. To migrate placed structures to a new ID, a server-side script must iterate the StructureManager placed-structure list and update the ID references before the server loads the save with the new ID set.

Structure placement audio design and player feedback

The PlacementAudioClip field on the structure asset controls the audio feedback the player hears on successful placement. A well-chosen placement sound provides immediate confirmation that the structure was placed correctly and at the intended grid position. The cohort recommendation is to use distinct audio clips for each material type: a wooden thud for wood structures, a metallic clang for metal structures, and a heavier impact for stone or brick structures. The audio clip should be short (under 1 second) to avoid overlapping with subsequent placement actions during rapid building sequences.

Multi-story base design and structural integrity

The Unturned™ structural system does not enforce vertical load limits. A single pillar can support any number of floors and walls stacked above it without structural failure. The only vertical constraint is the Terrain_Test_Height of each floor piece: each successive floor must be within its Terrain_Test_Height distance from the terrain below, regardless of how many floors are between them. For extreme-height bases (20+ stories), each floor must have Terrain_Test_Height set to at least the total base height above terrain.

Does the Proof_Explosion flag affect the structure's destruction effect?

No. Proof_Explosion controls whether the structure takes damage from explosion-type damage sources. The destruction effect (the Explosion field) is triggered when the structure reaches Health 0 regardless of what damage source reduced it to zero. An explosion-immune structure that is destroyed by sustained gunfire still plays its destruction effect. The Explosion field and the Proof_Explosion flag are independent systems that do not interact.

Can an existing structure be converted to a different Construct type after placement?

No. The Construct type is read from the .dat file at asset load time and determines the grid validation rules for that structure type throughout the server session. A placed structure's Construct type is locked at placement and does not change if the .dat file is updated. To change a structure's grid behavior, the existing placed structure must be destroyed or salvaged, the .dat file must be updated with the new Construct type, and a new structure must be placed using the updated asset.

Best practices

• Match the Construct type to the intended grid position before authoring the mesh. A wall mesh placed on a floor grid position will not validate even if the geometry looks correct.
• Set Has_Clip_Prefab false for every structure unless you have a specific performance reason to use a separate clip prefab. The default true value forces the server to search for a clip prefab that most structure mods do not provide.
• Author collision meshes to fit exactly within the 3m grid cell boundary. A collision mesh that extends beyond the cell prevents adjacent structure placements.
• Set Foliage_Cut_Radius to 6.0 as a baseline for floor and wall structures. Higher values on foundation floors (up to 10.0) provide a cleaner building footprint.
• Use Terrain_Test_Height generously. A value of 25 allows ground-level placement on terrain with moderate elevation changes without restricting elevated base construction.
• Set Eligible_For_Pull true on all player-buildable structures. The default false creates permanent clutter on servers when players leave without salvaging their bases.
• Include Proof_Explosion on metal-tier and higher structures. Without it, a single explosive charge bypasses the entire armor tier system.
• Author Armor_Tier to match the material narrative - wood structures are Low, metal structures are High, and brick or reinforced structures are High. The name-based default in the engine also checks for Metal and Brick in the structure name.
• Test every Construct type placement in single-player before publishing. The grid validation system produces no console errors for placement failures; the only indicator is the placement preview turning red when the position is invalid.

Frequently asked questions

What is the difference between Construct Wall and Construct Rampart?

Both Wall and Rampart occupy vertical grid positions and share the same placement validation logic. The difference is in the intended geometry and gameplay function. Wall is a standard flat vertical panel - the typical base wall. Rampart is an angled or stepped defensive wall - a crenelated parapet or sloped fortification that provides partial cover for defenders while allowing them to fire over the top. The mesh geometry for each should reflect the intended gameplay role.

Can a single structure have multiple Construct types?

No. The Construct field accepts a single enum value per structure .dat. Each structure piece instantiates as exactly one grid element with one set of snap rules. If you want a structure that serves both as a wall and as a floor (a wall with a catwalk, for example), author two separate structure assets - one Construct Wall and one Construct Floor - and pair them in the mod's building guide documentation.

What happens when a structure's supporting piece is destroyed?

If a wall is destroyed, any roof that was supported by that wall also becomes unsupported. The engine does not immediately destroy unsupported structures on the supporting piece's destruction. The orphaned roof piece remains in the world but cannot be used as a support for additional placement. If the player removes all supporting elements, the orphaned pieces remain as floating structures that can only be removed by destruction or salvage. This is by design; immediate cascading destruction would create a severe griefing vector in PvP contexts.

How do I make a structure that floats without ground contact?

A structure placed on terrain requires Terrain_Test_Height to be set high enough for the terrain raycast. To create a genuinely floating structure (a sky base with no ground contact), place the first Floor piece with Terrain_Test_Height set to the distance from the desired height to the ground. The floor must have terrain within Terrain_Test_Height distance below it; it cannot be placed over an infinite void. For maps with a solid terrain layer at a fixed depth, this is always achievable.

What is the maximum health value for a structure?

The Health field is a uint16, which has a maximum value of 65535. A structure with Health 65535 is effectively indestructible through normal gameplay damage. For structures that should be genuinely indestructible, use Can_Be_Damaged false instead; it prevents damage from all sources and does not require balancing health against weapon damage values.

Does Foliage_Cut_Radius affect tree removal?

Foliage_Cut_Radius affects only foliage-level objects - grass, small bushes, ground cover plants, and similar low vegetation. It does not affect tree removal or rock removal. For clearing trees and large obstacles, the level editor's terrain tools or server-side terrain modification commands are required. The field exists to prevent ground-level vegetation from clipping through placed structure floors.

Can a structure be placed on water?

Structures cannot be placed on water surfaces by default. The engine's placement raycast requires a solid surface hit, and water surfaces are not considered solid for structure placement. For water-based structures (docks, piers, floating platforms), the structure must be placed on a solid underwater surface at a depth within Terrain_Test_Height distance, or the map must include artificial solid surfaces at the waterline level.

How does the double Type field work on structure .dat files?

Structure .dat files contain two Type fields. The first occurrence sets the top-level asset category (Type Structure). The second occurrence sets the Construct sub-type (Type Wall, Type Floor, etc.). Both fields use the exact key name Type with no distinguishing prefix. The Unturned™ parser reads them in order: the first Type value determines the asset class resolver, and the second Type value determines the Construct enum for grid snapping. Both must be present. A structure .dat with only one Type field will default to fallback behavior that may not match the intended grid placement.

Why does my wall require pillars when I expected it to be free-standing?

The Requires_Pillars field defaults to true on the ItemStructureAsset class. If the .dat does not explicitly set Requires_Pillars false, the engine treats the wall as requiring pillars on both vertical edges. For ground-floor walls on a foundation, explicitly set Requires_Pillars false to allow placement directly on floor panels without pillar constraints.

What happens if I set Terrain_Test_Height to a very low value?

A low Terrain_Test_Height value (such as 1.0) restricts floor placement to terrain that is very close to the floor's pivot position. On uneven terrain, the floor may fail to place on elevated ground where the distance from the floor to the terrain exceeds the test height. On flat terrain, a low value is acceptable. For general-purpose structures, keep Terrain_Test_Height at 10.0 or higher.

Authoring checklist

Before publishing a structure mod to the Steam Workshop, confirm the following:

• [ ] GUID is unique - generated fresh, not copied from another asset
• [ ] ID is in the 50000+ range
• [ ] Construct enum value matches the intended grid behavior
• [ ] Requires_Pillars is set to match the intended placement flexibility
• [ ] Terrain_Test_Height is high enough for the target maps and intended elevation
• [ ] Foliage_Cut_Radius is set to a positive value unless foliage should persist
• [ ] Health is set to a reasonable value for the structure's material tier
• [ ] Armor_Tier matches the intended material narrative
• [ ] Can_Be_Damaged reflects the intended durability state
• [ ] Proof_Explosion is present for base-defense structures
• [ ] Has_Clip_Prefab false unless a separate clip prefab exists
• [ ] Collision mesh fits within the 3m grid cell boundary
• [ ] English.dat is authored with Name and Description
• [ ] Prefab is built into a master bundle and copied to the Bundles/ folder
• [ ] Placement range is tested for the intended build distance
• [ ] The structure snaps to the correct grid position for its Construct type
• [ ] Adjacent structure placements are not blocked by oversized collision
• [ ] The structure can be damaged to Health 0 and destroys correctly
• [ ] Crafting blueprint is tested and produces the correct item from the correct materials

Appendix A: Structure asset .dat quick reference

Field	Type	Required	Default
ID	uint16	Yes	-
GUID	uint128	Yes	-
Type	enum (Structure)	Yes	-
Useable	enum (Structure)	Yes	-
Construct	enum	Yes	-
Name	string	Yes	-
Rarity	enum	No	Common
Slot	enum	Yes	-
Size_X	uint8	Yes	-
Size_Y	uint8	Yes	-
Range	float	No	4.0
Terrain_Test_Height	float	No	10.0
Foliage_Cut_Radius	float	No	6.0
Health	uint16	No	0
Armor_Tier	enum	No	Low
Can_Be_Damaged	bool	No	true
Proof_Explosion	flag	No	not set
Vulnerable	flag	No	not set
Can_Zombies_Target	bool	No	true
Requires_Pillars	bool	No	true
Salvage_Duration_Multiplier	float	No	1.0
Unpickupable	flag	No	not set
Unrepairable	flag	No	not set
Unsalvageable	flag	No	not set
Unsaveable	flag	No	not set
Eligible_For_Pooling	bool	No	true
Has_Clip_Prefab	bool	No	true
Foliage_Cut_Radius	float	No	6.0
PlacementAudioClip	bundle pointer	No	-
PlacementPreviewPrefab	bundle pointer	No	-
Explosion	GUID/uint16	No	-

Appendix B: Structure health reference by material tier

Material tier	Typical wall health	Typical floor health	Typical roof health	Armor_Tier	Notes
Wood	500	500	400	Low	Standard wooden construction
Metal	1800	1800	1500	High	Corrugated metal panels
Armored plate	3500	3500	3000	High	Top vanilla tier
Brick / stone	2500	2500	2000	High	Mod-added tier
Glass	50	50	50	Low	Decorative only
Admin indestructible	Any	Any	Any	Any	Use Can_Be_Damaged false

Custom structures should fall somewhere in these ranges unless designed for a specific gameplay purpose. A structure with health significantly above the armored plate tier (4000+) will feel indestructible to most players and should be reserved for event set-pieces, admin structures, or quest-critical buildings that should not be destroyed during normal gameplay.

Appendix C: External references

• Smartly Dressed Games official modding documentation - Structure assets - the authoritative field reference for structure asset types.
• Unturned on Steam - the Unturned™ store page and community hub.
• Objects, Structures, and Barricades - the companion guide covering the three-category distinction and structural grid behavior.
• Barricade Asset Reference - the previous article; barricade and structure share the ItemPlaceableAsset base class.
• Placeable Asset Reference - the next article; covers the ItemPlaceableAsset base class fields inherited by structure assets.
• Item Asset Anatomy - the shared identity field reference for all item types.
• Project Folder Structure and GUIDs - GUID generation and folder layout for item mods.
• Master Bundle Export - the Unity bundling workflow for structure prefabs.

Cross-references

• Objects, Structures, and Barricades - the companion three-category guide covering structural grid behavior, the Object-Structure-Barricade distinction, and collision pitfalls for structure mods.
• Barricade Asset Reference - the previous article; covers the barricade asset type that shares the ItemPlaceableAsset base class with structures.
• Placeable Asset Reference - the next article; documents the base class fields (ItemPlaceableAsset) inherited by both structure and barricade assets.
• Item Asset Anatomy - the shared identity field reference for all item assets.
• Project Folder Structure and GUIDs - GUID generation and folder layout for all item mod types.
• Master Bundle Export - the Unity bundling pipeline for packaging structure prefabs into .unity3d bundles.
• Smartly Dressed Games modding documentation - the official field reference for structure assets.
• Unturned on Steam - the game's Steam page and community hub.

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete structure .dat field reference, Construct enum, grid validation rules, armor tier system, worked examples, placement troubleshooting, and balance reference table.