Placeable Asset Reference

Intermediate40-60 minutesWindowsNotepad++Unity Editor

The ItemPlaceableAsset class is the base class from which both ItemBarricadeAsset and ItemStructureAsset derive. It defines the shared field surface that applies to every player-placeable item in Unturned™ - the drop-on-destroy system, the salvage recovery system, the crafting tag provider system, and the explosion effect positioning system. Understanding the ItemPlaceableAsset base class is essential for any mod author working with barricades or structures, because fields defined on this base class are inherited by both derived types and cannot be overridden or suppressed at the subclass level.

57 Studios™ has documented and validated the complete ItemPlaceableAsset field surface across the Unturned™ modding community. This article covers every field on the ItemPlaceableAsset base class as documented in the official Smartly Dressed Games modding reference: the Item_Dropped_On_Destroy field controlling what items spawn when a placeable is destroyed, the Min_Items_Recovered_On_Salvage and Max_Items_Recovered_On_Salvage fields controlling partial resource recovery on pickup, the PlaceableProvidesCraftingTags system that exposes crafting tags to nearby players, the SalvageItem and SalvageItem_FullHealth fields for overriding default salvage behavior, the ExplosionEffect_CopyModelPosition and ExplosionEffect_CopyModelRotation fields for fine-tuning destruction effects, and the full salvage and recovery math with Items_Recovered_On_Salvage_Full_Health. Two worked examples - a standard campfire barricade and a metal storage crate - demonstrate the base class fields applied through both the barricade and structure subclass paths.

Documentation source: This article references the official Smartly Dressed Games modding documentation for field definitions and game behavior. 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 already authored or are in the process of authoring barricade or structure assets. The ItemPlaceableAsset base class fields covered here are inherited by all placeable subclasses - you do not need to add them to your .dat files separately, but you must understand their defaults and how to override them. If you have not yet read the Barricade Asset Reference or Structure Asset Reference, read at least one of those first to understand the subclass field surface before working through the base class. If you are new to Unturned™ modding, start with Item Asset Anatomy and Project Folder Structure and GUIDs before returning here.

What you'll learn

• The complete ItemPlaceableAsset field set inherited by all barricade and structure assets
• The drop-on-destroy system: Item_Dropped_On_Destroy, Min_Items_Dropped_On_Destroy, Max_Items_Dropped_On_Destroy, and the Items_Dropped_On_Destroy shorthand
• The salvage recovery system: Min_Items_Recovered_On_Salvage, Max_Items_Recovered_On_Salvage, Min_Items_Recovered_On_Salvage_Full_Health, Max_Items_Recovered_On_Salvage_Full_Health, and all shorthand variants
• The salvage override system: SalvageItem and SalvageItem_FullHealth for directing salvage output to specific items or spawn tables
• The PlaceableProvidesCraftingTags system for exposing crafting tags to nearby players
• The explosion effect positioning system: ExplosionEffect_CopyModelPosition and ExplosionEffect_CopyModelRotation
• The this string value shorthand for self-referencing GUIDs
• Worked examples demonstrating base class field configuration for both barricade and structure assets
• Full diagnostic troubleshooting table for salvage and drop-on-destroy behaviors

How the placeable base class system works

Every placeable item in Unturned™ inherits from ItemPlaceableAsset, which itself inherits from ItemAsset. The inheritance chain means that every field defined on ItemPlaceableAsset is available on every barricade and structure .dat file, and every field defined on ItemAsset is also available. When the engine loads a barricade or structure .dat, it reads fields from all three levels of the inheritance hierarchy. A field set at the ItemPlaceableAsset level (such as Item_Dropped_On_Destroy) applies to both barricades and structures identically.

As shown in the inheritance diagram above, the ItemPlaceableAsset class sits in the middle of the item hierarchy. Fields that are common to both barricades and structures are defined here. Fields that are specific to one subclass are defined on that subclass. The base class fields cannot be overridden by subclass fields; they are additive.

Complete placeable asset .dat field reference

Drop-on-destroy fields

When a placeable item is destroyed (its Health reaches zero), the engine can spawn one or more items at the destruction location. The drop-on-destroy system controls what items are dropped and how many.

Field	Type	Default	Purpose
Item_Dropped_On_Destroy	asset pointer	-	The item asset or spawn table that is spawned when the placeable is destroyed. Can be a GUID, a legacy uint16 ID, or the string value this which uses the owning item's own GUID.
Min_Items_Dropped_On_Destroy	int	0	The minimum number of items to drop when the placeable is destroyed.
Max_Items_Dropped_On_Destroy	int	0	The maximum number of items to drop when the placeable is destroyed.
Items_Dropped_On_Destroy	int	-	Shorthand for setting both Min_Items_Dropped_On_Destroy and Max_Items_Dropped_On_Destroy to the same value. Using Items_Dropped_On_Destroy 1 is equivalent to setting both min and max to 1.

The drop-on-destroy system is distinct from the salvage system. Drop-on-destroy triggers automatically when the placeable is destroyed by damage. The salvage system triggers when a player actively salvages (picks up) the placeable. These are independent systems and both can be configured on the same placeable.

The drop-on-destroy system is used by vanilla Unturned for lootable containers that spill their contents when destroyed, for resource nodes that drop raw materials, and for explosive barricades that detonate and drop nothing.

Salvage recovery fields

When a player salvages (picks up) a placeable item, the salvage recovery system determines how many items the player receives. The system supports different recovery amounts depending on whether the placeable was at full health or damaged when salvaged.

Field	Type	Default	Purpose
Min_Items_Recovered_On_Salvage	int	1	The minimum number of items to receive when the placeable is salvaged below 100% health.
Max_Items_Recovered_On_Salvage	int	1	The maximum number of items to receive when the placeable is salvaged below 100% health.
Items_Recovered_On_Salvage	int	-	Shorthand for setting both Min_Items_Recovered_On_Salvage and Max_Items_Recovered_On_Salvage to the same value.
Min_Items_Recovered_On_Salvage_Full_Health	int	1	The minimum number of items to receive when the placeable is salvaged at 100% health.
Max_Items_Recovered_On_Salvage_Full_Health	int	1	The maximum number of items to receive when the placeable is salvaged at 100% health.
Items_Recovered_On_Salvage_Full_Health	int	-	Shorthand for setting both Min_Items_Recovered_On_Salvage_Full_Health and Max_Items_Recovered_On_Salvage_Full_Health to the same value.

The salvage recovery system is distinct from the crafting blueprint system. When a player crafts a placeable item from blueprints and then salvages it, the recovery system determines how many raw materials are returned. A typical configuration for a wooden wall: the crafting blueprint requires 5 planks, and the salvage recovery returns 1-3 planks (depending on damage) - representing the partial recovery of materials from the destroyed wall.

Salvage override fields

By default, the salvage system selects a random item from the placeable's crafting blueprint input items. The salvage override fields allow the mod author to direct the salvage output to a specific item or spawn table instead.

Field	Type	Default	Purpose
SalvageItem	asset pointer	(random blueprint input)	Override the default salvage behavior by pointing to a specific item or spawn table that should be added when salvaging a placeable that is below 100% health.
SalvageItem_FullHealth	asset pointer	(self)	Override the default salvage behavior by pointing to a specific item or spawn table that should be added when salvaging a placeable that is at 100% health. Defaults to this (the placeable item itself), meaning salvaging a full-health placeable returns the placeable item to the player's inventory. Can also be set to the string value this, which uses the owning item's own GUID.

The distinction between SalvageItem and SalvageItem_FullHealth is important for gameplay balance. Salvaging a damaged placeable should typically return fewer or lower-quality materials than salvaging an undamaged one. The default behavior (random blueprint input for damaged, self for full health) implements this asymmetry correctly for most use cases.

Crafting tag fields

Crafting tags expose special properties to nearby players for blueprint requirements. A placeable that provides the HeatSource tag, for example, allows nearby players to craft recipes that require a heat source.

Field	Type	Default	Purpose
PlaceableProvidesCraftingTags	list of asset pointer	-	A list of Tag Asset GUIDs that are available to nearby players for blueprint requirements. Tags are listed in the item description as "crafting capabilities." For example, the vanilla Brick Oven provides two tags: the HeatSource tag (20f30322bbcc4b01a4f116d22b24c21a) and the Enclosed Heat Source tag (d2cc65b749e5477f95103601df89cdbc).

The PlaceableProvidesCraftingTags field is populated as a list in the .dat file. The syntax is:

PlaceableProvidesCraftingTags
[
20f30322bbcc4b01a4f116d22b24c21a
d2cc65b749e5477f95103601df89cdbc
]

Each entry in the list is a GUID referencing a Tag Asset. The tags are provided to any player within the proximity radius defined by the tag asset. Multiple tags can be provided by a single placeable, and the same tag can be provided by multiple placeables in the same area.

Explosion effect fields

The explosion effect fields control how the destruction effect (the Explosion effect defined on the barricade or structure subclass) is positioned and oriented when the placeable is destroyed.

Field	Type	Default	Purpose
ExplosionEffect_CopyModelPosition	bool	false	If true, the destruction effect spawns exactly at the model's position without any offset adjustments. Defaults to false for backwards compatibility, which may apply a position offset.
ExplosionEffect_CopyModelRotation	bool	false	If true, the destruction effect spawns with the same rotation as the model. Defaults to false for backwards compatibility. When true, the effect orientation matches the placeable's world rotation, which produces more natural-looking destruction effects for rotated placeables.

These fields are set to true for most modern placeable assets. The backwards compatibility defaults (false for both) produce destruction effects at the world origin point of the model without rotation, which can appear misaligned for rotated placeables.

The this string value

Both Item_Dropped_On_Destroy and SalvageItem_FullHealth support the string value this as an alternative to specifying a GUID or legacy ID. When this is used, the engine substitutes the owning placeable item's own GUID at load time. This is a convenience feature that avoids accidentally writing the wrong ID when the intended behavior is to return or destroy the same item.

Examples of this usage:

// Drop the placeable's own item when destroyed
Item_Dropped_On_Destroy this

// Return the placeable's own item when salvaged at full health
SalvageItem_FullHealth this

Using this is the cohort-recommended pattern for placeable items where the drop-on-destroy or salvage-full-health behavior should return the same item. It eliminates the possibility of a stale ID reference surviving an item ID change during development.

Worked example: campfire barricade with drop-on-destroy

The following .dat file extends the barricade asset surface from the barricade reference with ItemPlaceableAsset base class fields. This campfire is a Build Campfire type barricade that drops sticks when destroyed and returns itself when salvaged at full health.

ID 50500
GUID a1b2c3d4e5f64a7b8c9d0e1f2a3b4c5d
Type Barricade
Useable Barricade
Build Campfire
Name CustomCampfire
Rarity Common
Slot Barricade
Size_X 1
Size_Y 1

Health 100
Range 3.0
Radius 1.0
Offset 0.0

Allow_Placement_On_Vehicle false
Can_Be_Damaged true
Can_Zombies_Target true

PlaceableProvidesCraftingTags
[
20f30322bbcc4b01a4f116d22b24c21a
]

Item_Dropped_On_Destroy 50501
Min_Items_Dropped_On_Destroy 1
Max_Items_Dropped_On_Destroy 3

Min_Items_Recovered_On_Salvage 1
Max_Items_Recovered_On_Salvage 2
Min_Items_Recovered_On_Salvage_Full_Health 1
Max_Items_Recovered_On_Salvage_Full_Health 1

SalvageItem_FullHealth this

ExplosionEffect_CopyModelPosition true
ExplosionEffect_CopyModelRotation true

Companion English.dat:

Name Campfire
Description A wood-burning campfire that provides light, heat, and a heat source crafting tag to nearby players. Drops sticks when destroyed.

In this example, the PlaceableProvidesCraftingTags field exposes the vanilla HeatSource tag. The drop-on-destroy fields specify that 1 to 3 sticks (item ID 50501) are dropped when the campfire is destroyed. The salvage recovery fields specify that 1-2 items are recovered on salvage when damaged, and exactly 1 item (the campfire itself, via SalvageItem_FullHealth this) is recovered on salvage at full health.

Worked example: storage crate with salvage override

The following .dat file demonstrates a storage crate barricade with a salvage override that returns a specific salvage item instead of the default random blueprint input.

ID 50510
GUID b2c3d4e5f6a74a8b9c0d1e2f3a4b5c6d
Type Barricade
Useable Barricade
Build Storage
Name CustomSalvageCrate
Rarity Common
Slot Barricade
Size_X 2
Size_Y 1

Health 400
Range 3.0
Radius 1.5
Offset 0.0

Allow_Placement_On_Vehicle false
Can_Be_Damaged true
Can_Zombies_Target false

Item_Dropped_On_Destroy this
Min_Items_Dropped_On_Destroy 0
Max_Items_Dropped_On_Destroy 0

Min_Items_Recovered_On_Salvage 1
Max_Items_Recovered_On_Salvage 1
Min_Items_Recovered_On_Salvage_Full_Health 1
Max_Items_Recovered_On_Salvage_Full_Health 1

SalvageItem 50511
SalvageItem_FullHealth this

Companion English.dat:

Name Salvage Crate
Description A storage crate with full materials recovery on full-health salvage. Returns scrap metal when salvaged from damaged state.

In this example, SalvageItem points to item ID 50511 (scrap metal) for damaged salvage, and SalvageItem_FullHealth uses this to return the crate itself when salvaged at full health. The drop-on-destroy system is configured with this as the item but zero min and max, meaning the engine will not actually drop anything on destruction - the this reference is a placeholder in case the configuration is later updated.

Worked example: structure with crafting tags

The following .dat file demonstrates a structure (Construct Wall) that provides crafting tags to nearby players. Industrial crafting bases often require nearby crafting stations with specific tags.

ID 50520
GUID c3d4e5f6a7b84a9c0d1e2f3a4b5c6d7
Type Structure
Useable Structure
Construct Wall
Name CustomWorkbenchWall
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

PlaceableProvidesCraftingTags
[
e7a1f2b3c4d54a6b7c8d9e0f1a2b3c4d
f8b2c3d4e5f64a7b8c9d0e1f2a3b4c5d
]

Item_Dropped_On_Destroy 50521
Min_Items_Dropped_On_Destroy 2
Max_Items_Dropped_On_Destroy 4

Min_Items_Recovered_On_Salvage 0
Max_Items_Recovered_On_Salvage 0
Min_Items_Recovered_On_Salvage_Full_Health 1
Max_Items_Recovered_On_Salvage_Full_Health 1

SalvageItem_FullHealth this

ExplosionEffect_CopyModelPosition true
ExplosionEffect_CopyModelRotation true

Companion English.dat:

Name Workbench Wall
Description A reinforced wall panel with integrated crafting station functionality. Provides two crafting tags to nearby players.

Advanced worked example: salvage and drop configuration matrix

The following example demonstrates a comprehensive salvage and drop configuration for a multi-tier placeable system. Three placeable variants share the same base class fields but use different salvage and drop settings to produce different gameplay behaviors.

Variant A: Resource node (generous drop)

This placeable drops many items on destruction but returns nothing on salvage. It is designed for renewable resource nodes that should reward destruction but not salvage.

ID 50600
GUID d4e5f6a7b8c94a0b1c2d3e4f5a6b7c8d

Item_Dropped_On_Destroy 50601
Min_Items_Dropped_On_Destroy 3
Max_Items_Dropped_On_Destroy 6

Min_Items_Recovered_On_Salvage 0
Max_Items_Recovered_On_Salvage 0
Min_Items_Recovered_On_Salvage_Full_Health 0
Max_Items_Recovered_On_Salvage_Full_Health 0

ExplosionEffect_CopyModelPosition true
ExplosionEffect_CopyModelRotation true

Variant B: Storage container (balanced)

This placeable returns itself on full-health salvage, drops nothing on destruction, and provides partial material recovery on damaged salvage. This is the standard configuration for player-built storage containers.

ID 50610
GUID e5f6a7b8c9d04a1b2c3d4e5f6a7b8c9d

Item_Dropped_On_Destroy this
Min_Items_Dropped_On_Destroy 0
Max_Items_Dropped_On_Destroy 0

Min_Items_Recovered_On_Salvage 1
Max_Items_Recovered_On_Salvage 3
Min_Items_Recovered_On_Salvage_Full_Health 1
Max_Items_Recovered_On_Salvage_Full_Health 1

SalvageItem_FullHealth this

ExplosionEffect_CopyModelPosition true
ExplosionEffect_CopyModelRotation true

Variant C: Quest prop (no recovery)

This placeable drops nothing on destroy, returns nothing on salvage, and is not recoverable. It is designed for one-time quest props that should disappear permanently.

ID 50620
GUID f6a7b8c9d0e14a2b3c4d5e6f7a8b9c0d

// No Item_Dropped_On_Destroy - nothing drops on destruction
Min_Items_Recovered_On_Salvage 0
Max_Items_Recovered_On_Salvage 0
Min_Items_Recovered_On_Salvage_Full_Health 0
Max_Items_Recovered_On_Salvage_Full_Health 0

// Unsalvageable on the subclass .dat prevents pickup entirely

The three variants above cover the most common placeable salvage and drop patterns. The configuration values are starting points; actual values depend on the mod's intended gameplay economy.

Salvage recovery math

The salvage recovery system uses the health percentage of the placeable at the time of salvage to determine which set of recovery fields applies. The math is straightforward.

If salvaged at full health (100%):
  Use Min_Items_Recovered_On_Salvage_Full_Health and Max_Items_Recovered_On_Salvage_Full_Health

If salvaged below full health (less than 100%):
  Use Min_Items_Recovered_On_Salvage and Max_Items_Recovered_On_Salvage

The engine picks a random integer between the min and max values (inclusive) for the appropriate set of fields. If Min_Items_Recovered_On_Salvage is 2 and Max_Items_Recovered_On_Salvage is 5, the player will receive 2, 3, 4, or 5 items on a damaged salvage.

┌─────────────────────────────────────────────────────────────────┐
│  Salvage recovery math example - Wooden Wall                    │
│                                                                 │
│  Blueprint: 5 planks to craft                                   │
│  No salvage overrides (default: random blueprint input)          │
│                                                                 │
│  Salvage at full health:                                         │
│    Min_Recovered_Full: 1, Max_Recovered_Full: 1                 │
│    Result: 1 item - the wall item itself (default behavior)     │
│                                                                 │
│  Salvage at 60% health:                                          │
│    Min_Recovered: 1, Max_Recovered: 3                            │
│    Result: 1-3 planks selected randomly from blueprint inputs    │
│                                                                 │
│  Salvage at 10% health (nearly destroyed):                       │
│    Same set applies (Min_Recovered: 1, Max_Recovered: 3)         │
│    Result: 1-3 planks - health percentage below full does not    │
│    further reduce recovery; only the full-health threshold       │
│    produces different behavior.                                  │
└─────────────────────────────────────────────────────────────────┘

The key design insight is that the salvage system has only two tiers: full health and below-full health. There is no continuous scaling of recovery based on current HP percentage. A placeable at 1% health recovers the same number of items as a placeable at 99% health. If finer-grained recovery scaling is desired, it must be implemented through server-side script logic rather than through the .dat salvage fields.

Placeable prefab considerations

The ItemPlaceableAsset base class does not impose specific prefab structure requirements beyond those inherited from ItemAsset. However, the prefab hierarchy for a placeable must account for the networking behavior, the destruction effect system, and the salvage interaction system that are unique to placeable items.

Prefab root requirements

Requirement	Detail
Root transform position	World origin offset (0, 0, 0) in the prefab. The engine applies world placement transforms at runtime.
Root scale	Uniform scale (1, 1, 1). Non-uniform scale on the prefab root produces incorrect collision behavior.
Root rotation	Default rotation (0, 0, 0). Rotation is applied by the placement system based on the player's facing direction.
Rigidbody	Not required on the prefab root for static placeables. Only animated or moving placeables require a Rigidbody.

Destruction effect child GameObjects

When the placeable is destroyed, the engine looks for the Explosion effect asset at the prefab root position. If the placeable has custom destruction effects (particle systems, sound emitters, light flashes), these should be children of the prefab root with the Play On Awake flag enabled on the ParticleSystem. The engine disables the placeable's main mesh and enables the destruction effect child on the destruction event.

Salvage interaction triggers

Salvage interaction is handled by the engine's standard interactability system. The prefab does not require any custom script or trigger collider for salvage functionality. The engine detects the salvage interaction through the barricade or structure manager's input system, reads the salvage configuration from the .dat file, and processes the salvage recovery without any prefab-side component. The only prefab requirement for salvage is that the placeable has a collider that the player's interaction raycast can hit.

Diagnostic table

Symptom	Most likely cause	Resolution
Placeable drops nothing when destroyed	Item_Dropped_On_Destroy not set or set to wrong GUID	Set Item_Dropped_On_Destroy to the correct item GUID, legacy ID, or this
Placeable drops too many items on destruction	Max_Items_Dropped_On_Destroy set too high	Reduce the max value to match the intended drop count
Placeable drops no items on salvage	Min_Items_Recovered_On_Salvage set to 0 and Max_Items_Recovered_On_Salvage set to 0	Set min and max to at least 1
Salvage returns the wrong item	SalvageItem or SalvageItem_FullHealth override set to the wrong GUID	Correct the override GUID or remove it to return to default behavior
Salvage at full health returns nothing	Min_Items_Recovered_On_Salvage_Full_Health and Max_Items_Recovered_On_Salvage_Full_Health both set to 0 with no SalvageItem_FullHealth override	Set full-health salvage to return at least 1 item
Destruction effect appears at wrong position	ExplosionEffect_CopyModelPosition set to false	Set ExplosionEffect_CopyModelPosition true
Destruction effect has wrong rotation	ExplosionEffect_CopyModelRotation set to false	Set ExplosionEffect_CopyModelRotation true
Placeable provides no crafting tags in nearby crafting UI	PlaceableProvidesCraftingTags list is empty	Populate with the correct tag asset GUIDs
Placeable provides wrong crafting tags	PlaceableProvidesCraftingTags contains the wrong tag GUIDs	Replace with the correct tag asset GUIDs from the tag asset references
this reference fails at load time	The placeable item's GUID is missing or invalid	Confirm the GUID field is present and correctly formatted
Salvage returns the placeable itself when damaged	SalvageItem is set to this instead of a lower-value salvage item	Set SalvageItem to a different item GUID for damaged salvage
Drop-on-destroy drops the placeable itself	Item_Dropped_On_Destroy this when intentionally dropping a different item	Change to the intended item's GUID or legacy ID
Min and max values produce inconsistent counts	Min and max set to different values with a small range	Set them closer together or use the shorthand field for a fixed count
Salvage yields no items despite min/max set to 1	The Unsalvageable flag on the barricade or structure subclass overrides salvage	Remove the Unsalvageable flag from the subclass .dat
Placeable vanishes on destruction with no visual effect	Explosion field on the subclass is not set	Set the Explosion field on the barricade or structure to a valid effect GUID or legacy ID

Best practices

• Set ExplosionEffect_CopyModelPosition and ExplosionEffect_CopyModelRotation both to true for all modern placeable assets. The backwards-compatibility defaults produce misaligned destruction effects on rotated placeables.
• Use the Items_Dropped_On_Destroy shorthand when the min and max should be the same value. It reduces the chance of a typo where min exceeds max.
• Use the Items_Recovered_On_Salvage shorthand for the same reason when salvage recovery should be a fixed count.
• Use SalvageItem_FullHealth this as the default for placeable items that should be fully recoverable when salvaged at full health. This is the cohort-validated standard pattern.
• For damaged salvage, set SalvageItem to a lower-tier material or component rather than returning the full placeable item. A damaged wall should not return a pristine wall item.
• Populate PlaceableProvidesCraftingTags only for placeables that genuinely provide crafting utility. Not every barricade or structure needs crafting tags, and each tag adds a proximity check that consumes server performance.
• Test both full-health and damaged salvage in single-player before publishing. The two-tier salvage system produces different behaviors that are easy to overlook during authoring.
• For Item_Dropped_On_Destroy, prefer using this when the destroyed placeable should drop its own item (such as a campfire dropping itself as a lootable item). Use a specific GUID when the drop should be a different item.
• Keep drop-on-destroy counts reasonable for performance. A placeable that drops 50 items on destruction creates 50 entity spawns that must be cleaned up. Standard values are 1-5 items.

Frequently asked questions

What is the difference between drop-on-destroy and salvage?

Drop-on-destroy triggers when the placeable is destroyed by damage (reaching Health 0). Salvage triggers when a player actively picks up the placeable using the interact action. Drop-on-destroy spawns items at the destruction location as world entities. Salvage adds items directly to the player's inventory. The two systems are independent; a placeable can have both configured, only one, or neither.

Can I make a placeable that drops nothing on destroy and nothing on salvage?

Yes. Set all Min_Items_Dropped_On_Destroy and Max_Items_Dropped_On_Destroy to 0 (or omit Item_Dropped_On_Destroy), and set all salvage min and max values to 0. The placeable will simply disappear when destroyed or salvaged with no item output. This is appropriate for disposable barriers, one-use props, and event decorations.

What happens if Min_Items_Dropped_On_Destroy is higher than Max_Items_Dropped_On_Destroy?

The engine clamps the max value to be at least the min value. If min is 5 and max is 3, the effective range is 5 to 5 - the placeable always drops exactly 5 items. Avoiding this configuration is recommended; use the Items_Dropped_On_Destroy shorthand instead when a fixed count is intended.

How do I make a placeable that drops different items depending on its destroyed state?

The .dat file supports a single Item_Dropped_On_Destroy item reference. There is no state-dependent drop trigger in the base class. For different drops based on destroyed state (such as a wall that drops planks when destroyed by melee but drops nothing when destroyed by explosion), server-side scripting through the Unturned™ API is required.

Can PlaceableProvidesCraftingTags reference more than two tags?

Yes. The list can contain any number of tag asset GUIDs, limited only by the .dat file's practical length. Each tag adds a proximity check, so a placeable with many tags consumes proportionally more server CPU time on each proximity check tick. The cohort recommendation is to keep the tag list to 5 or fewer tags per placeable.

What is the default SalvageItem when no override is set?

When SalvageItem is not set, the engine selects a random item from the placeable's crafting blueprint input items. If the placeable has a blueprint requiring 5 planks and 2 nails, the random selection picks either planks or nails for each unit of salvage recovery. The randomization is per-unit, meaning a salvage that returns 3 items might return 2 planks and 1 nail.

Does SalvageItem_FullHealth default to the placeable's own item?

Yes. The default value for SalvageItem_FullHealth is this - the placeable's own GUID. This means salvaging a full-health placeable returns the placeable item itself to the player's inventory by default. This is the behavior players expect: picking up an undamaged placed item should give them the item back.

Can I set Item_Dropped_On_Destroy to a spawn table instead of a single item?

Yes. Item_Dropped_On_Destroy accepts both item asset pointers and spawn table asset pointers. When set to a spawn table, the engine rolls the spawn table on each drop event and returns a random item from the table according to the table's weight configuration. This is useful for placeables that should drop a random selection from a predefined pool of items.

What happens if both salvage and drop-on-destroy trigger on the same frame?

The salvage system takes priority over the drop-on-destroy system. If a player salvages a placeable at the same moment it reaches Health 0 from damage (a rare race condition), the salvage system executes first and the drop-on-destroy system does not trigger. In practice, the two systems operate on distinct trigger conditions (player interaction versus damage event) and do not conflict. The priority ordering is only relevant in edge cases involving simultaneous server events.

How does the engine handle Min/Max when only one is set?

If Min_Items_Dropped_On_Destroy is set to 2 but Max_Items_Dropped_On_Destroy is omitted, the max defaults to 0. The engine clamps max to be at least min, so the effective range is 2 to 2 - the placeable always drops exactly 2 items. The same logic applies to all min/max pairs on the ItemPlaceableAsset class. The safest approach is to always set both min and max explicitly, or to use the shorthand field for a fixed count.

Can a placeable provide crafting tags to enemies?

The PlaceableProvidesCraftingTags system is proximity-based with no faction or ownership filtering. Any player within the tag's proximity radius receives the tag regardless of whether they are allied with or hostile to the placeable's owner. This means an enemy player building near an owned campfire gains the same HeatSource tag benefit as the campfire's owner. There is no field on the base class to restrict crafting tag access by ownership or group membership.

Is there a limit to how many items can appear in the PlaceableProvidesCraftingTags list?

There is no hard limit enforced by the engine. The practical limit is determined by the .dat file's length and the server's performance under load. Each tag in the list requires the server to run a proximity check for every crafting recipe evaluation within range. A placeable with 50 tags will trigger 50 proximity checks per player per crafting attempt. The cohort recommendation is to keep tag lists to 5 or fewer tags per placeable to avoid unnecessary server CPU consumption.

Advanced considerations

Salvage economy design for placeable-based game modes

On servers where placeable items are a primary game mechanic (such as faction-based base-building servers), the salvage configuration directly shapes the server's material economy. A generous salvage configuration (high min/max values, full-health recovery returning the full item) reduces material scarcity and encourages players to rebuild frequently. A strict salvage configuration (low min/max values, damaged salvage returning only partial materials) increases material pressure and rewards careful base defense. The salvage configuration should be tuned to the server's intended material economy, not to a one-size-fits-all default. The cohort practice is to provide a recommended salvage configuration in the mod's workshop documentation and to note that server administrators can override salvage behavior through the server's plugin system.

Interaction between SalvageItem and crafting blueprint costs

When SalvageItem is not set (default behavior), the salvage recovery draws from the placeable's crafting blueprint input items. This means a placeable with a high-cost blueprint (requiring 10 planks, 5 nails, and 2 metal sheets) will have a varied salvage pool that can return any of those items. If the crafting blueprint costs are changed after the placeable has been placed on live servers, the salvage pool changes accordingly. Placeable items that were placed under the old blueprint cost will salvage under the new blueprint cost when salvaged after the blueprint update. This is intentional: salvage always uses the current blueprint configuration, not the blueprint configuration at the time of placement.

Network synchronization of salvage and drop events

Salvage and drop events are server-authoritative operations. When a player salvages a placeable, the client sends a salvage request to the server; the server validates the request, processes the salvage recovery, and broadcasts the result to all clients in the area. The salvage recovery item count is determined on the server and cannot be influenced by the client. This means salvage-related exploits (client-side manipulation to increase recovery count) are not possible. The same server-authoritative model applies to drop-on-destroy events: the server spawns the dropped items and broadcasts their positions to clients.

Authoring placeable items for quest and event systems

Placeable items that are part of quest chains or server events should set SalvageItem_FullHealth this and Item_Dropped_On_Destroy to a quest item or to nothing depending on the quest design. A quest placeable that should persist until the quest is complete should use Unpickupable and Unrepairable from the subclass flags to prevent premature removal. A quest placeable that should be destroyable and drop a quest item on destruction should configure Item_Dropped_On_Destroy with the quest item GUID and set the min and max to 1. Quest placeables should not use the default salvage behavior (which returns random blueprint inputs) because the random result may not align with the quest design.

PlaceableProvidesCraftingTags and server performance at scale

On servers with hundreds of active placeable instances, the PlaceableProvidesCraftingTags system performs a proximity check for each tag on each tick for each nearby player. The performance cost scales as O(players × placeables × tags). For a server with 50 players and 1000 placeables each providing 3 crafting tags, the proximity check system evaluates 150,000 distance calculations per tick. The cohort recommendation for high-population servers is to limit crafting tags to essential placeables only and to keep the tag list to 2-3 tags per placeable at most. Decorative placeables, storage containers, and non-production placeables should omit PlaceableProvidesCraftingTags entirely.

Explosion effect field migration for older placeable assets

Placeable assets authored before the introduction of ExplosionEffect_CopyModelPosition and ExplosionEffect_CopyModelRotation default both fields to false. When these placeables are loaded in a current Unturned™ version, the destruction effect appears at the model's base position with zero rotation. Updating older placeable assets to set both fields to true is a quick migration that produces visually correct destruction effects at no performance cost. The migration is purely cosmetic; it does not affect any gameplay behavior.

Drop-on-destroy spawning and item cleanup

Items spawned by the Item_Dropped_On_Destroy system are regular world-item entities subject to the server's item cleanup timer. On a default server configuration, dropped items persist for 5 minutes before despawning. This means a placeable that drops 10 items on destruction creates 10 world-item entities that must be cleaned up by the server's garbage collection system. On servers with frequent placeable destruction (raid-heavy PvP servers), the cumulative cleanup load from drop-on-destroy items is a meaningful performance factor. The cohort recommendation for these server types is to keep Max_Items_Dropped_On_Destroy at or below 5 and to set Item_Dropped_On_Destroy to a single-item reference rather than a spawn table where possible.

Why would I set ExplosionEffect_CopyModelRotation to false?

Setting ExplosionEffect_CopyModelRotation to false produces an explosion effect that always faces the world forward direction (identity rotation) regardless of the placeable's rotation. This is the backwards-compatible default. For placeables where the destruction effect does not have a meaningful orientation (a spherical explosion, for example), the rotation does not matter and the false default is acceptable. For placeables where the destruction effect has a direction (a directional explosion, a particle burst that should match the wall's facing), set it to true.

What happens if I use a legacy uint16 ID instead of a GUID for Item_Dropped_On_Destroy?

Both formats are accepted. The engine resolves legacy uint16 IDs at load time by looking up the matching asset in the loaded asset set. GUIDs are preferred for new mods because they are globally unique and do not require ID-range coordination with other mods. Legacy IDs are supported for backwards compatibility with older mods that predate the GUID requirement.

Does the explosion effect consume server resources?

The destruction effect defined by the Explosion field on the subclass (not the ItemPlaceableAsset base class) is a one-shot effect that spawns at the destruction position. It is a fire-and-forget operation: the engine spawns the effect, plays it once, and destroys it. The effect consumes resources only during its lifetime (typically 1-5 seconds for a particle effect). ExplosionEffect_CopyModelPosition and ExplosionEffect_CopyModelRotation have no measurable performance impact because they modify only the spawn position and rotation of the effect, not its complexity.

Can I use ExplosionEffect_CopyModelPosition with a placeable that has no explosion effect?

Yes. Setting these fields on a placeable with no Explosion field defined on the subclass has no effect. The fields are applied only when the destruction effect is actually triggered. They can be safely included in every placeable .dat without checking whether the Explosion field is set.

What happens to Items_Dropped_On_Destroy items if the player's inventory is full?

Items spawned by the drop-on-destroy system are spawned as world entities at the placeable's position, not added to the player's inventory. They exist on the ground as pickup-able world items regardless of the player's inventory state. The player must manually pick them up. This is different from the salvage system, which adds items directly to the player's inventory and will reject items if the inventory is full.

How do I configure a placeable that drops different item counts based on the damage type that destroyed it?

The .dat file does not support damage-type-conditional field values. A single Item_Dropped_On_Destroy reference applies to all destruction events regardless of the damage source. For damage-type-specific drops, a server-side script that hooks the BarricadeManager.onBarricadeDamaged or StructureManager.onStructureDamaged event and conditionally spawns items based on the damage source is required.

How does the engine round fractional drop counts from the random range?

The engine uses Random.Range(min, max + 1) with integer casting, producing an inclusive integer range. Min_Items_Recovered_On_Salvage 1 and Max_Items_Recovered_On_Salvage 4 produces evenly-distributed results of 1, 2, 3, or 4 items. There is no floating-point rounding or weighted distribution; each integer in the range has equal probability.

Can SalvageItem_FullHealth be set to a different value per-player?

No. The salvage fields are static configuration values read once at asset load time and applied uniformly to all players. Per-player salvage behavior (such as a perk that improves salvage yield for certain players) requires server-side scripting that intercepts the salvage event and modifies the output before it is added to the player's inventory.

What happens if a placeable is destroyed by an explosion but Item_Dropped_On_Destroy drops an explosion-vulnerable item?

The drop-on-destroy items are spawned after the destruction effect resolves. They are not affected by the explosion that destroyed the placeable. The dropped items are placed at the destruction position with zero velocity and are not subjected to the explosion's damage or force. However, if a second explosion occurs at the same position while the dropped items are still on the ground, the dropped items can be destroyed by that second explosion as regular world items.

Does the salvage recovery system preserve item durability or quality?

No. Items returned by the salvage system are spawned as new item instances with default durability and quality. Any modifications applied to the original placeable item (such as item condition changes, paint, or attachment modifications) are lost on salvage. Only the item type and quantity are preserved. Condition-dependent salvage behavior (returning fewer items when the placeable is damaged) is controlled by the Min_Items_Recovered_On_Salvage / Max_Items_Recovered_On_Salvage fields and does not require item-level durability tracking.

Can I configure salvage recovery to scale with the player's skill level?

The ItemPlaceableAsset base class does not include a player-skill scaling field for salvage recovery. Salvage values are static per asset and apply uniformly to all players. For skill-based salvage scaling, a server-side plugin that hooks the salvage event and multiplies the recovery count by a per-player skill factor is required. The .dat salvage fields should be set to the baseline values for a player with no skill modifier.

Can I skip setting salvage fields entirely?

Yes. If no salvage fields are set in the .dat, the engine uses the defaults: Min_Items_Recovered_On_Salvage 1, Max_Items_Recovered_On_Salvage 1, Min_Items_Recovered_On_Salvage_Full_Health 1, Max_Items_Recovered_On_Salvage_Full_Health 1, and SalvageItem_FullHealth defaulting to self. This produces the standard behavior where salvaging a full-health placeable returns the placeable item and salvaging a damaged placeable returns one random blueprint input item. Most placeable mods can use the defaults without modification.

Authoring checklist

Before publishing a placeable mod that uses base class fields, confirm the following:

• [ ] Item_Dropped_On_Destroy is set if the placeable should drop items on destruction. Omitted if no drop is intended.
• [ ] Min_Items_Dropped_On_Destroy and Max_Items_Dropped_On_Destroy are consistent and match the intended drop count range
• [ ] Salvage min/max values are set appropriately for the placeable's role
• [ ] SalvageItem_FullHealth is set to this for full return, or to a different GUID for a different return item
• [ ] SalvageItem is set if the damaged salvage should return a different item than the default random blueprint input
• [ ] PlaceableProvidesCraftingTags is populated with the correct tag asset GUIDs if the placeable provides crafting utility
• [ ] ExplosionEffect_CopyModelPosition is set to true for modern placeables
• [ ] ExplosionEffect_CopyModelRotation is set to true for directional destruction effects
• [ ] The Unsalvageable flag on the barricade or structure subclass is consistent with the salvage recovery configuration
• [ ] Full-health salvage tested: picking up an undamaged placeable returns the item
• [ ] Damaged salvage tested: picking up a damaged placeable returns fewer or different items
• [ ] Drop-on-destroy tested: destroying the placeable spawns items at its position

Appendix A: Placeable asset base class .dat quick reference

Field	Type	Required	Default
Item_Dropped_On_Destroy	asset pointer (GUID, uint16, or this)	No	-
Min_Items_Dropped_On_Destroy	int	No	0
Max_Items_Dropped_On_Destroy	int	No	0
Items_Dropped_On_Destroy	int	No	- (shorthand)
Min_Items_Recovered_On_Salvage	int	No	1
Max_Items_Recovered_On_Salvage	int	No	1
Items_Recovered_On_Salvage	int	No	- (shorthand)
Min_Items_Recovered_On_Salvage_Full_Health	int	No	1
Max_Items_Recovered_On_Salvage_Full_Health	int	No	1
Items_Recovered_On_Salvage_Full_Health	int	No	- (shorthand)
SalvageItem	asset pointer	No	(random blueprint input)
SalvageItem_FullHealth	asset pointer	No	this (self)
PlaceableProvidesCraftingTags	list of asset pointers	No	(empty)
ExplosionEffect_CopyModelPosition	bool	No	false
ExplosionEffect_CopyModelRotation	bool	No	false

Appendix B: Salvage configuration template

Use this template as a starting point for placeable item salvage configuration. Adjust the values for the specific placeable type.

// Default salvage: full health returns self, damaged returns random blueprint input
// No fields needed - the default behavior covers most use cases.

// Aggressive salvage: always returns self regardless of health
SalvageItem_FullHealth this
SalvageItem this

// Strict salvage: full health returns self, damaged returns nothing
SalvageItem_FullHealth this
Min_Items_Recovered_On_Salvage 0
Max_Items_Recovered_On_Salvage 0

// Generous salvage: full health returns self plus bonus materials
SalvageItem_FullHealth this
Min_Items_Recovered_On_Salvage 2
Max_Items_Recovered_On_Salvage 4
SalvageItem <bonus-material-guid>

// One-way placeable: no salvage, no drop on destroy
// Omit all salvage and drop fields
// (Add Unsalvageable flag on the subclass)

Appendix C: External references

• Smartly Dressed Games official modding documentation - Placeable assets - the authoritative field reference for the ItemPlaceableAsset base class.
• Unturned on Steam - the Unturned™ store page and community hub.
• Barricade Asset Reference - the preceding article; covers the ItemBarricadeAsset subclass that inherits from ItemPlaceableAsset.
• Structure Asset Reference - the preceding article; covers the ItemStructureAsset subclass that inherits from ItemPlaceableAsset.
• Objects, Structures, and Barricades - the companion guide covering the three-category distinction and placement pitfalls.
• 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 placeable prefabs.

Cross-references

• Barricade Asset Reference - the preceding article; documents the ItemBarricadeAsset fields that extend the ItemPlaceableAsset base class for barricade-specific behavior.
• Structure Asset Reference - the preceding article; documents the ItemStructureAsset fields that extend the ItemPlaceableAsset base class for structure-specific behavior.
• Objects, Structures, and Barricades - the companion three-category guide covering the distinction between Object, Structure, and Barricade asset types with placement and collision pitfalls.
• Item Asset Anatomy - the shared identity field reference for all item assets across all types.
• Project Folder Structure and GUIDs - GUID generation, folder layout, and the item mod project structure conventions.
• Master Bundle Export - the Unity bundling pipeline for packaging placeable prefabs into .unity3d bundles.
• Beacon Asset Reference - the next article; covers the beacon asset type that inherits from the barricade class and extends the placeable fields.
• Smartly Dressed Games modding documentation - the official field reference for the ItemPlaceableAsset base class and all derived types.
• Unturned on Steam - the game's Steam page and community hub.

Placeable asset design patterns

The following design patterns are recurring configurations for the ItemPlaceableAsset base class fields. Each pattern corresponds to a specific gameplay role and can be used as a starting template for new placeable assets.

The renewable resource

A placeable that drops items on destruction but provides no salvage return. Used for resource nodes that should be destroyed to collect materials.

• Item_Dropped_On_Destroy: set to the resource item GUID
• Min/Max_Items_Dropped_On_Destroy: 3 to 6
• All salvage fields: 0 or omitted
• Unsalvageable flag recommended on the subclass .dat

The storage container

A placeable that returns itself on full-health salvage, provides partial material return on damaged salvage, and drops nothing on destruction.

• Item_Dropped_On_Destroy: this or omitted
• SalvageItem_FullHealth: this
• Min/Max_Items_Recovered_On_Salvage: 1 to 3
• Unsalvageable: not set

The one-time prop

A placeable that cannot be salvaged, drops nothing on destruction, and is fully permanent once placed. Used for quest props, event decorations, and server-owned structures.

• All salvage fields: 0 or omitted
• Item_Dropped_On_Destroy: omitted
• Unpickupable and Unrepairable flags recommended on the subclass .dat

The crafting station

A placeable that provides crafting tags to nearby players, supports full salvage recovery, and drops materials on destruction.

• PlaceableProvidesCraftingTags: populated with the relevant tag GUIDs
• SalvageItem_FullHealth: this
• Min/Max_Items_Recovered_On_Salvage: 1 to 2
• Item_Dropped_On_Destroy: set to a material item GUID

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete ItemPlaceableAsset base class .dat field reference, drop-on-destroy system, salvage recovery system, crafting tag system, worked examples, salvage template, and salvage recovery math.