Resource Asset

Intermediate40-60 minutesWindowsUnity EditorBlenderNotepad++

Harvestable world resources — trees, rocks, mining nodes, and ore deposits — are defined by the resource asset system in Unturned™. A resource asset is a world object that can be damaged by a player using an appropriate tool, and that yields one or more items when its HP reaches zero. After being destroyed, the resource can optionally regrow at its original spawn position after a configurable time delay.

57 Studios™ has documented and validated the complete resource asset configuration surface across a range of custom map and content mod projects. This article covers every .dat field used to define resource assets, the four major resource categories (deciduous trees, evergreen trees, rock formations, and ore mining nodes), harvest tool requirements, regrowth and spawning behavior, and how to place custom resources on a custom map.

Documentation source: This article references the official Smartly Dressed Games modding documentation for authoritative field definitions. Community-validated notes are marked where the official documentation is silent on behavior.

Who this article is for

This article targets mod authors who are building custom content for Unturned™ maps — either as a standalone map mod with custom resources, or as a content mod that adds new resource types to existing maps via the Workshop resource injection system. Familiarity with the master bundle pipeline, .dat file authoring, and GUID workflow is assumed. If you need background on these topics, see Project Folder Structure and GUIDs first.

How the resource system works

Unturned's resource runtime is managed by the ResourceManager and the ResourceAsset configuration. When a map loads, the ResourceManager reads spawn tables and spawner placements to determine where resource nodes exist in the world. Each placement references a resource asset by GUID. At the referenced position, the engine instantiates the resource node's prefab and attaches the runtime HP state from the Health field in the .dat.

When a player strikes the resource with a melee weapon, the ResourceManager checks whether the weapon meets the resource's tool requirements, then applies Damage_* from the melee weapon's .dat to the resource's HP. When HP reaches zero, the resource plays a destruction animation, spawns item drops according to the Reward_* configuration, removes the resource node from the world, and starts the regrowth timer.

The key insight from this sequence is that the melee weapon controls how much damage is applied per swing (Damage_Resource in the melee .dat), but the resource asset controls everything else: how much HP the node has, what it drops when destroyed, whether the harvesting tool is constrained, and how long regrowth takes.

Resource categories

The resource system in Unturned™ supports four primary categories of harvestable node. Each category uses the same .dat field schema but represents a different world object class.

Category	Examples	Primary drop	Damage type
Deciduous tree	Oak, birch, maple, dead tree	Wood logs, sticks	Damage_Resource (axe)
Evergreen tree	Pine, spruce, fir	Wood logs, needles	Damage_Resource (axe)
Rock / boulder	Surface boulders, cliff faces	Stone, pebbles	Damage_Resource (pickaxe)
Ore mining node	Iron node, lead node, gold node	Metal ore chunks	Damage_Resource (pickaxe)

All four categories share the same .dat structure. The visual appearance, the drop items, and the tool requirements differentiate them.

File and folder structure

A resource asset requires the following files:

Workshop/Content/304930/<modID>/
├── Bundles/
│   └── <BundleName>.unity3d          ← master bundle containing the resource prefab
└── Resources/
    └── MyTree/
        ├── MyTree.dat                ← primary configuration
        └── English.dat               ← display name (shown on interact prompt)

Resource assets live in a Resources/ subfolder within the mod's content folder, not in Items/. This is a different folder from item assets and is important for the engine's content loading logic.

Complete .dat field reference

Identity fields

Field	Type	Example	Required	Purpose
ID	uint16	8001	Yes	Numeric resource ID. Must be unique across all loaded mods. Use IDs in the 50000+ range to avoid collision with vanilla resources.
GUID	uint128 hex	e1f2a3b4c5d64e7f8a9b0c1d2e3f4a5b	Yes	128-bit globally unique identifier. Generate a new GUID per resource.
Type	enum	Resource	Yes	Must be Resource for resource assets.
Name	string	CustomOakTree	Yes	Internal name. Referenced in spawn tables and map editor.

GUID uniqueness

Each resource asset must have a unique GUID, distinct from any item asset GUIDs. Resource assets and item assets share the same GUID namespace; a collision between a resource GUID and an item GUID will cause one to be silently overwritten at load time. Generate fresh GUIDs for every asset of every type.

HP and damage fields

Field	Type	Unit	Default	Purpose
Health	uint16	HP	100	The total HP of the resource node. A higher value requires more swings (or swings with a more powerful tool) to destroy.
Explosion	uint16	HP threshold	0	If set, the resource node explodes (dealing area damage) when destroyed. Primarily used for explosive barrels and hazard objects, not standard resources. Set to 0 for all standard trees and rocks.
Reset	float	seconds	0	Alias for the regrowth timer when used in certain map configurations. Prefer Regrow for clarity.

::: callout HP balance guidelines

Resource type	Suggested Health	Rationale
Small sapling / shrub	10–25	Quick to harvest; yields minimal drops
Standard deciduous tree	75–100	Takes 5–8 swings with a standard axe
Large tree / old growth	150–200	Takes 10–15 swings; rare spawn, larger yield
Small surface rock	50–75	Takes 5–8 swings with a standard pickaxe
Large boulder	100–150	Significant effort; larger stone yield
Common ore node (iron)	80–120	Moderate effort; standard ore yield
Rare ore node (gold)	150–200	High effort; proportionally valuable yield

These guidelines assume a harvesting tool with Damage_Resource 20. Adjust Health proportionally if your tool convention uses different Damage_Resource values. :::

Reward fields

The reward fields define what items are spawned when the resource is fully harvested (HP reaches zero).

Field	Type	Example	Required	Purpose
Reward_ID	uint16	5	Yes	The item ID of the primary drop. 5 is vanilla wood log. Use your custom item ID for a custom drop.
Reward_Min	uint8	3	Yes	The minimum number of items dropped on destruction.
Reward_Max	uint8	5	Yes	The maximum number of items dropped on destruction. The engine randomly selects a count in the [Min, Max] range per destruction event.
Reward_XP	uint32	5	No	The amount of player XP awarded when the resource is fully harvested.

Reward_ID references vanilla item IDs

Reward_ID references an item by its numeric ID, not by GUID. This means it can reference both vanilla items and custom mod items. For a vanilla wood log, use ID 5. For a custom ore item, use the numeric ID from your custom item's .dat. The item must be loaded in the same mod session for the drop to resolve correctly. If the referenced item ID is not loaded, the drop silently produces nothing.

Secondary reward fields

A resource can drop up to two distinct item types on destruction. The secondary reward uses the following fields:

Field	Type	Example	Purpose
Reward_ID_2	uint16	76	Item ID of the secondary drop. 76 is vanilla sticks.
Reward_Min_2	uint8	1	Minimum count of secondary drops.
Reward_Max_2	uint8	3	Maximum count of secondary drops.

Example: a tree that drops 3–5 wood logs and 1–3 sticks uses both the primary and secondary reward fields simultaneously.

Regrowth fields

Field	Type	Unit	Default	Purpose
Regrow	float	seconds	0	The time in seconds after destruction before the resource node respawns at its original position. 0 = the node does not respawn.
Vulnerable_To_All_Melee	flag	—	not set	If present, the resource takes damage from any melee weapon regardless of tool requirements. If absent and Requires_Harvest_Tool is set, only matching tools deal damage.

::: callout Regrowth timing guidelines

Resource type	Suggested Regrow	Rationale
Sapling / small shrub	600–900 (10–15 min)	Fast renewable; low value
Standard tree	1800–3600 (30–60 min)	Moderate renewable rate
Large tree	3600–7200 (60–120 min)	Slow renewable; high value drop
Surface rock	3600 (60 min)	Stone is plentiful; moderate renewal
Common ore node	3600–7200 (60–120 min)	Ore nodes should feel scarce
Rare ore node (gold)	7200–14400 (120–240 min)	Rare resource requires real wait
Non-renewable (set 0)	0	One-shot loot nodes; never respawn

A Regrow value of 0 is appropriate for destructible world objects that are part of the map's permanent geography (cliff-face rocks, fallen logs) rather than renewable resource nodes. For a resource that players are expected to farm, always set a positive Regrow value. :::

Harvest tool requirement fields

Field	Type	Default	Purpose
Requires_Harvest_Tool	flag	not set	If present, the resource only takes Damage_Resource from melee weapons that are recognized as valid harvest tools. Melee weapons without the relevant tag deal 0 resource damage.

The Requires_Harvest_Tool flag works in conjunction with the melee weapon's configuration. In the vanilla engine, an axe-class weapon is recognized as a valid harvest tool for wood resources, and a pickaxe-class weapon is recognized for rock and ore resources. Custom tool classes can be configured via the mod's content definition.

When Requires_Harvest_Tool is present and a player attempts to harvest with an invalid tool (e.g., attacking a mining rock with a kitchen knife), the node takes no damage and may display a feedback message indicating the wrong tool.

When Requires_Harvest_Tool is absent and Vulnerable_To_All_Melee is present, any melee weapon can harvest the resource, regardless of type. This is appropriate for fragile resources (dry grass, mushrooms, fragile crystals) where the design intent is accessibility rather than tool specialization.

Tree variants

Unturned™ supports two primary tree categories: deciduous (broadleaf) and evergreen (conifer). Both use the same .dat schema. The distinction is visual — the prefab defines the mesh — and ecological — map spawn tables can separate them by category for biome-appropriate distribution.

Deciduous trees

Deciduous trees are broadleaf trees: oaks, birches, maples, aspens. They typically appear in temperate biomes. The vanilla deciduous tree drops wood logs and sticks.

ID 50200
GUID f2a3b4c5d6e74f8a9b0c1d2e3f4a5b6c
Type Resource
Name CustomOakTree

Health 100
Reward_ID 5
Reward_Min 3
Reward_Max 5
Reward_ID_2 76
Reward_Min_2 1
Reward_Max_2 3
Reward_XP 5

Regrow 1800

Requires_Harvest_Tool

Evergreen trees

Evergreen trees are conifer trees: pines, spruces, firs. They typically appear in boreal and alpine biomes. The vanilla evergreen tree also drops wood logs, but with different visual feedback and slightly different spawn ecology.

Evergreen trees often have a taller, narrower prefab with a different destruction animation (the tree falls as a whole rather than sectioning). The .dat configuration is identical to a deciduous tree — the prefab and destruction animation drive the visual difference.

::: callout Dead trees Dead trees (bare trunks with no leaves) are a common map aesthetic element. Configuring a dead tree resource:

• Lower Health (50–75) — dead wood is more brittle
• Lower Reward_Min / Reward_Max — dead wood yields less usable material
• Higher Regrow or Regrow 0 — dead trees that fall do not regrow in a logical ecology
• Can use the same Reward_ID as a living tree (dead wood is still wood) :::

Rock and boulder variants

Rock formations are the primary source of stone in Unturned™. They appear as surface boulders, cliff outcroppings, and cave wall sections. The resource .dat for a rock is structurally identical to a tree but references stone as the primary reward.

Vanilla stone is item ID 36 (stone). Vanilla pebbles are item ID 441. A custom surface boulder configuration:

ID 50201
GUID a3b4c5d6e7f84a9b1c2d3e4f5a6b7c8d
Type Resource
Name CustomBoulder

Health 120
Reward_ID 36
Reward_Min 4
Reward_Max 7
Reward_ID_2 441
Reward_Min_2 2
Reward_Max_2 4
Reward_XP 8

Regrow 3600

Requires_Harvest_Tool

Mining nodes

Mining nodes are resource assets specifically designed to yield ore and metal materials. They are distinguished from standard rocks by their prefab (a rock face with visible ore veins), their higher Health (more effort required), their Reward_ID pointing to ore items rather than stone, and their Requires_Harvest_Tool flag which restricts them to pickaxe-type tools.

Ore type reference

The following table maps common ore types to their expected resource .dat configuration parameters:

Ore type	Suggested Health	Reward_ID (custom item)	Reward_Min	Reward_Max	Regrow (sec)
Iron ore	100	Custom iron ore item ID	2	4	3600
Lead ore	80	Custom lead ore item ID	1	3	5400
Copper ore	90	Custom copper ore item ID	2	4	4200
Gold ore	160	Custom gold ore item ID	1	2	10800
Coal	70	Custom coal item ID	3	6	2700
Crystal / gem	200	Custom gem item ID	1	1	14400

Because ore items are typically custom items specific to your mod, Reward_ID should reference the numeric ID of your custom ore item .dat, not a vanilla item.

Full iron ore node example

ID 50202
GUID b4c5d6e7f8094a1b2c3d4e5f6a7b8c9d
Type Resource
Name IronOreNode

Health 100
Reward_ID 50300
Reward_Min 2
Reward_Max 4
Reward_XP 10

Regrow 3600

Requires_Harvest_Tool

In this example, Reward_ID 50300 references a custom iron ore chunk item with its own .dat at ID 50300.

Prefab structure for resource assets

A resource prefab differs from an item prefab. The resource prefab is a world-placed scene object, not an inventory model. The minimum cohort-validated hierarchy for a tree resource:

MyTreePrefab (root, with Resource script)
├── Trunk (MeshRenderer + MeshFilter — the trunk mesh)
├── Canopy (MeshRenderer + MeshFilter — the leaf/needle canopy mesh)
├── Stump (MeshRenderer + MeshFilter — the stump left after harvesting, or this is hidden until destruction)
├── Animator (handles the destruction / falling animation)
└── AudioSource (for the axe-strike impact sound and fall sound)

For a rock or mining node:

MyRockPrefab (root, with Resource script)
├── Rock_Intact (MeshRenderer + MeshFilter — full rock, visible at full HP)
├── Rock_Damaged (MeshRenderer + MeshFilter — cracked version, optionally swapped at ~50% HP)
├── Dust_Particles (Particle System — spawned at destruction)
└── AudioSource (for strike and break sounds)

The Resource script component on the prefab root handles HP state, damage application, destruction event, and reward spawning. The script reads Health, Reward_ID, Reward_Min, Reward_Max, and Regrow from the linked .dat at runtime.

Level of Detail (LOD) for resource prefabs

Trees and rocks are common world objects and are often visible at long distances. The cohort recommendation is to author at least two LOD meshes for resource prefabs: a full-detail mesh (LOD0) and a simplified mesh (LOD1) at roughly 30–50% of the original polygon count. Unturned™ uses Unity's LOD Group component. Without LOD, dense resource placements can cause significant GPU load at distance.

Map-side resource placement

Custom resources become available on a map through two mechanisms: the resource spawner system (for density-based procedural placement) and direct placement in the Unity level editor (for hand-crafted positions).

Spawner-based placement

The spawner system places resources procedurally across the map based on spawn tables. A spawn table defines:

• Which resource GUIDs can spawn at this spawner type
• The probability weight of each GUID within the table
• The density parameters (average spacing, cluster size)

Spawn tables are defined in a JSON or .dat-format configuration file depending on the map type. The cohort recommendation is to consult the Smartly Dressed Games modding documentation for the current spawn table format, as the format has evolved across Unturned™ major versions.

Direct placement in the Unity level editor

For hand-crafted maps where specific resource positions matter (a mine entrance with specific ore veins, a lumber camp with a set grove of trees), resources can be placed directly as scene objects in the Unity map editor. The workflow is:

1. Import the resource prefab into the Unity project as an asset.
2. Drag the prefab into the scene at the desired world position.
3. Assign the resource .dat GUID to the placed instance's Resource component.
4. Adjust the rotation so the tree or rock faces the desired direction.
5. Confirm the position is on the terrain surface (no floating or clipping).
6. Save the scene and rebuild the map bundle.

Directly-placed resources do not go through the spawn table system — they exist at fixed positions regardless of spawn table settings. They still respect Regrow timing; after being harvested, they disappear and respawn at the same fixed position after the configured seconds.

Interaction with the melee asset system

The resource asset and the melee asset are connected through the Damage_Resource field on the melee weapon. To harvest a custom resource node efficiently, players need a melee weapon with sufficient Damage_Resource to defeat the node's Health within a reasonable number of swings.

::: callout Designing the tool-to-resource relationship When authoring both a custom resource and a custom harvesting tool, design the relationship from the player experience first:

1. Decide the target swing count — how many swings should fully harvest this resource with the intended tool? 5 swings is fast (good for common resources); 15 swings is slow (good for rare/valuable resources).
2. Set Health accordingly — Health = swing_count × Damage_Resource on the intended tool.
3. Set Reward proportional to effort — a 15-swing ore node should drop more ore than a 5-swing surface rock.
4. Set Regrow proportional to reward value — high-value nodes should take longer to respawn.

Example: gold node intended to take 10 swings with a steel pickaxe (Damage_Resource 20) → Health 200, Reward_Min 1, Reward_Max 2, Regrow 10800. :::

Testing resource assets in single-player

1. Copy the master bundle and .dat files to the local Unturned™ install.
2. Launch a map that includes the custom resource (either via direct placement in the map or via a spawn table that includes the resource GUID).
3. Spawn a harvesting tool with sufficient Damage_Resource: @give <toolID>.
4. Locate the resource node in the world.
5. Strike the node with the harvesting tool. Confirm:
   • The node's HP decrements (visual feedback on the node if a damage state mesh exists).
   • The damage per swing matches Damage_Resource / Health × 100% of the node's HP.
6. Continue striking until the node is destroyed. Confirm:
   • Item drops spawn on the ground at the node's position.
   • The count of drops is within [Reward_Min, Reward_Max].
   • XP is awarded to the player (if Reward_XP is set).
7. Wait for the Regrow timer. Confirm the node respawns at the same position after the configured seconds.
8. Test with an invalid tool (if Requires_Harvest_Tool is set):
   • Strike the node with a combat knife or other non-harvesting melee weapon.
   • Confirm the node takes 0 damage (or shows the wrong-tool feedback).

Diagnostic table

Symptom	Most likely cause	Resolution
Resource node not visible on map	Master bundle not loaded; prefab not assigned in .dat	Check bundle path; confirm prefab reference in Resource script
Resource takes no damage from any tool	.dat not linked to the placed prefab	Confirm GUID linkage between prefab Resource component and .dat
Resource takes damage from wrong tool	Requires_Harvest_Tool flag missing	Add the flag to restrict damage to valid harvest tools
Resource does not drop items on destruction	Reward_ID references unloaded item	Confirm the item mod is active; check Reward_ID value
Drop count is always at minimum	Reward_Max equals Reward_Min	Increase Reward_Max to allow range
Resource does not regrow	Regrow set to 0 or not set	Set a positive Regrow value in seconds
Resource regrows instantly	Regrow set too low (e.g., 1)	Increase Regrow to a practical value
Resource health too low — too easy to harvest	Health too low for intended tool Damage_Resource	Increase Health to match intended swing count
Resource health too high — never harvested	Health too high relative to tool capability	Lower Health or increase Damage_Resource on the tool
XP not awarded on harvest	Reward_XP not set	Add Reward_XP with a positive value
Floating or clipping resource in map	Position not snapped to terrain	Adjust placement in Unity level editor; use terrain snap
LOD pop-in at distance	No LOD Group on prefab	Add LOD Group with at least two LOD levels
Destruction animation does not play	Animator not configured on prefab	Add Animator with destruction state to prefab

Best practices

• Generate a fresh GUID for every resource asset, separate from any item asset GUIDs.
• Use IDs in the 50000+ range to avoid collision with vanilla resources (which use IDs below 2000).
• Set Requires_Harvest_Tool on ore nodes and wood resources to enforce tool specialization.
• Always set Regrow to a positive value for renewable resources. A Regrow 0 node is permanently gone after first harvest.
• Use secondary reward fields (Reward_ID_2) to give resources byproduct drops (sticks from trees, pebbles from rocks).
• Author LOD meshes for resource prefabs placed at high density on maps.
• Balance Health against Damage_Resource on the intended harvesting tool, not against combat weapons.
• Test Requires_Harvest_Tool by explicitly attempting to harvest with an invalid weapon before shipping.
• Place a small number of resource nodes by hand in single-player for testing rather than relying on spawn tables — it gives faster iteration.
• Document the intended tool for each resource type in the Workshop description so players know what equipment to bring.

Frequently asked questions

What is the difference between Regrow and Reset?

Regrow is the primary field for configuring how long (in seconds) a resource takes to respawn after destruction. Reset is an older field alias that appears in some legacy .dat configurations and performs the same function. For new resource assets, use Regrow. If you encounter Reset in a vanilla or community .dat, it means the same thing.

Can a resource drop more than two distinct item types?

The native resource asset system supports up to two reward item types (primary and secondary via Reward_ID / Reward_ID_2). To produce more than two distinct item types from a single harvest, the cohort recommendation is to use a custom item whose Type is Loot that itself references a loot table — that is, the resource drops a mystery bag item, and when the player opens the bag, the bag's loot table yields multiple item types. This is a workaround for the two-reward limit.

How do I make a resource that spawns in only one biome?

Biome-specific spawning is controlled by the spawn table, not by the resource .dat. In the spawn table configuration, assign the resource GUID to only the biome-specific spawner that covers the target biome area. On hand-crafted maps, simply place the resource prefab only in the intended biome area.

Can a resource be destroyed by weapons other than melee tools?

Yes. Vulnerable_To_All_Melee allows any melee weapon to deal Damage_Resource to the node. Additionally, resources can take damage from explosives and, in some configurations, from firearms with Resource_Damage set in the gun's .dat. The Requires_Harvest_Tool flag only restricts which melee weapons deal resource damage; it does not prevent explosive damage.

How do I make a resource that gives XP when partially harvested (not just on destruction)?

The base resource system awards XP only on final destruction (when HP reaches 0). Partial-harvest XP requires a custom scripted component attached to the resource prefab that hooks into the damage event and awards fractional XP per hit. This is outside the scope of the standard .dat configuration and requires Unity scripting knowledge. For standard mods, design XP rewards as a destruction bonus only.

What happens if two players harvest the same node simultaneously?

The resource HP pool is server-authoritative in a multiplayer session. Both players' damage is applied to the shared HP value. The first player to deal the final hit that reduces HP to 0 receives the XP award. Both players receive the item drops — items drop at the node's position and are available to any nearby player.

Can I make a resource that looks different at various HP thresholds?

Yes, through the prefab Animator. Author animation states for HP thresholds (e.g., intact, 75%, 50%, 25%) and trigger them via the Resource script's damage events. The engine supports mesh swapping within the destruction animation. The cohort recommendation is to have at least two states: intact and damaged (cracked/broken canopy, visible cut marks on a tree trunk). Full multi-stage damage requires careful animation authoring and is best suited to hero resources in a map rather than common spawnable nodes.

How do I reference a custom item as a reward instead of a vanilla item?

Set Reward_ID to the numeric ID value in your custom item's .dat. As long as the item mod is active in the same Workshop session or bundled in the same content mod, the engine resolves the ID to the correct item definition. Vanilla items have IDs below 2000; use IDs in the 50000+ range for custom items to avoid collision.

What is the maximum Health value a resource can have?

Health is a uint16 field, which supports a maximum value of 65535. In practice, a resource with Health above 500 will take an impractical number of swings with any standard tool and should only be used for special map events (a legendary tree that requires a full team effort to fell). For standard harvestable resources, keep Health below 200.

Can a resource have no regrowth at all?

Yes. Setting Regrow 0 (or omitting the field entirely, as the default is 0) produces a resource that is permanently gone after harvesting. This is appropriate for hand-placed environmental props that are there for map aesthetics or one-time content (a chest inside a cave, a crashed helicopter) rather than renewable farming nodes.

How do I add a sound to a resource's destruction event?

The destruction sound is played by the AudioSource component on the resource prefab. Author the audio clip and assign it to the AudioSource in Unity. The Resource script triggers the AudioSource at the destruction event. The cohort recommendation is to use a spatial audio source (Spatial Blend 1.0) so the sound falls off with distance, consistent with how players experience it.

Can a resource be harvested by a player-placed trap or automated mechanism?

In the base Unturned™ system, resource damage is only applied through direct player melee swings or explosions. Automated harvest is not natively supported. Custom server-side scripting (via the SDG Unturned Dedicated Server API) can implement automated harvesting, but this is outside the scope of the .dat system.

How do I create a mining node that yields different ore depending on the map?

The resource .dat is global — its Reward_ID is fixed. To have a node yield different ore on different maps, author separate resource assets (each with their own GUID and Reward_ID) and assign the appropriate GUID in each map's spawn table. Two maps can reference two different resource GUIDs that share the same visual prefab but have different reward configurations.

Appendix A: Resource asset .dat field quick reference

Field	Type	Required	Default	Purpose
ID	uint16	Yes	—	Numeric ID
GUID	uint128	Yes	—	Globally unique identifier
Type	enum (Resource)	Yes	—	Asset type
Name	string	Yes	—	Internal name
Health	uint16	Yes	100	Node HP
Explosion	uint16	No	0	Explosion damage on destruction
Reward_ID	uint16	Yes	—	Primary drop item ID
Reward_Min	uint8	Yes	—	Minimum drop count
Reward_Max	uint8	Yes	—	Maximum drop count
Reward_XP	uint32	No	0	XP awarded on harvest
Reward_ID_2	uint16	No	—	Secondary drop item ID
Reward_Min_2	uint8	No	—	Secondary drop minimum count
Reward_Max_2	uint8	No	—	Secondary drop maximum count
Regrow	float	No	0	Respawn timer in seconds
Reset	float	No	0	Legacy alias for Regrow
Requires_Harvest_Tool	flag	No	not set	Restrict damage to valid tools
Vulnerable_To_All_Melee	flag	No	not set	Any melee weapon deals resource damage

Appendix B: Vanilla resource ID reference

Vanilla resource	Internal name	Vanilla ID
Standard tree (deciduous)	Oak_Tree	1
Pine tree (evergreen)	Pine_Tree	2
Surface boulder	Boulder	3
Dead tree	Dead_Tree	4
Birch tree	Birch_Tree	7
Small rock	Small_Rock	9
Iron ore node	Iron_Ore	10
Lead ore node	Lead_Ore	11
Large boulder	Large_Boulder	13
Crystal deposit	Crystal	20

These IDs are for reference when using vanilla resources in spawn tables. Custom resource assets should use IDs in the 50000+ range.

Appendix C: External references

• Smartly Dressed Games official modding documentation — Resource assets — the authoritative field reference for resource assets.
• Unturned on Steam — the Unturned™ store page and community hub.
• Melee Asset — the previous article; covers the Damage_Resource field that tools use to harvest resource nodes.
• Objects and Structures Assets — the next article; covers non-harvestable world objects and player-built structures.
• Project Folder Structure and GUIDs — GUID generation and folder layout for all mod assets.
• Master Bundle Export — Unity bundling workflow for resource prefabs.
• Steam Workshop Submission — publishing workflow for finished mods.

Advanced considerations

Resource asset performance on high-density maps

Maps that use large forests or dense ore fields can place hundreds of resource nodes in a single chunk. Each resource node is an active runtime object tracked by the ResourceManager. On high-density maps, consider the following:

Concern	Mitigation
Draw call overhead	Combine static trunk/rock meshes using Unity's Static Batching. Resource nodes that will not animate their damage state can be marked static.
LOD pop-in	Author at least two LOD levels per resource prefab. LOD0 at full detail; LOD1 at 30–50% triangle count; LOD2 (optional billboard sprite) at extreme distance.
Physics collider count	Keep colliders simple. A tree trunk can use a single Capsule Collider on the trunk. The canopy typically does not need a collider for gameplay purposes.
Regrow timer load	The ResourceManager tracks a timer per destroyed node. On maps where thousands of nodes can be harvested simultaneously (e.g., a PvP server during an event), the timer count can be large. Ensure Regrow values are not unreasonably short (avoid values below 60 seconds for common nodes).

Authored damage state visuals

The base Resource script supports a simple destruction state: the node exists intact until HP reaches 0, then it is removed. For a more visually rich experience, authors can implement damage-state mesh swapping within the resource prefab:

1. Author three mesh states: intact, damaged (50% HP), critical (25% HP).
2. Use the Animator Controller to trigger state transitions when HP thresholds are reached.
3. The Resource script fires an animation trigger at 50% and 25% HP if the Animator has states bound to those thresholds.
4. Add particle effects (wood chips, stone dust) as child particle systems triggered at each damage event.

This workflow requires Unity Animator authoring knowledge but significantly improves the feedback quality for players harvesting resources.

Resource nodes as one-time map content

For custom maps where a resource node is a singular environmental feature — a shipwrecked cargo container full of loot, a single legendary ore vein at the center of a dungeon — set Regrow 0 and Reward_Max to a high value. These one-time nodes create a map-specific objective: players who reach and harvest the node first get the reward; all subsequent players find an empty spot. This is a common pattern in survival challenge maps and RP server event design.

Pairing custom resources with custom crafting

A custom resource that drops a custom item (e.g., a custom iron ore chunk with ID 50300) becomes most useful when paired with a crafting recipe that processes the raw material into a finished product. Unturned™'s crafting system reads Blueprint_* fields in item .dat files. A custom smelter recipe that takes 5 iron ore chunks and produces 1 iron ingot closes the resource-to-crafting loop. Designing this full loop — resource → raw material item → crafted item → player use — is the core of a survival economy mod and is one of the most rewarding design spaces in Unturned™ modding.

Resource assets in RP server economies

On roleplay servers, resources are often the foundation of a player-driven economy. A lumber company RP requires trees that respawn on a schedule matching the server's in-game economy tick rate. A mining guild RP requires ore nodes with scarcity that reflects the in-game value of metals. When authoring resources for RP contexts:

• Coordinate Regrow values with the server's economy designers to match intended scarcity.
• Use low Reward_Max values for high-value ores to prevent any single player from cornering the market in a single session.
• Consider authoring multiple quality tiers of the same ore (common iron node with Health 80, rare high-grade iron node with Health 160 and double Reward_Max) to create differentiated gathering experiences.
• Confirm with the server's plugin configuration whether harvest tool restrictions apply server-side in addition to (or instead of) the .dat-level Requires_Harvest_Tool flag.

Resource design patterns

The following design patterns represent proven resource configurations from 57 Studios™ map development. Each addresses a specific map-design goal.

The renewable lumber grove

A cluster of deciduous trees intended as the primary wood source for a mid-map safe zone. Designed so a solo player can gather enough wood for standard construction in two harvesting sessions per hour.

• Health 90 — 6 swings with a standard hatchet (Damage_Resource 15)
• Reward_Min 3, Reward_Max 5 — 3–5 logs per tree
• Reward_ID_2 set to sticks, Reward_Min_2 1, Reward_Max_2 3 — bonus sticks
• Regrow 1800 — 30-minute regrowth; two sessions per hour supported
• Requires_Harvest_Tool — enforces tool use; bare-handed or knife cannot harvest

Spawn table density: one spawner per 20 x 20 meters in the grove area. This produces a visually realistic forest that regenerates at a pace matching moderate server population.

The contested ore vein

A rare iron ore node placed in a high-risk zone to create a player-versus-player economic objective.

• Health 120 — 6 swings with a standard pickaxe
• Reward_Min 3, Reward_Max 5 — meaningful yield per node
• Reward_XP 15 — above-average XP to reward risk-taking
• Regrow 5400 — 90-minute regrowth; scarcity enforces competition
• Requires_Harvest_Tool — pickaxe required; prevents accidental harvesting

Place 3–5 of these nodes in a fixed location near a dangerous structure or zombie spawn. The regrowth timer and location create a recurring conflict point on the map.

The non-renewable dungeon deposit

A one-time crystal deposit placed inside a custom dungeon, accessible only by players who complete the dungeon. Destroyed permanently after harvesting.

• Health 200 — 10 swings; meaningful effort even in the dungeon context
• Reward_Min 1, Reward_Max 1 — exactly one crystal per node (scarcity by design)
• Reward_XP 50 — significant XP to mark the achievement
• Regrow 0 — does not regrow; the crystal is consumed permanently
• Requires_Harvest_Tool — requires a specialized tool found inside the dungeon (the tool is a quest item, not a standard pickaxe)

Place 1–3 of these nodes at the dungeon's conclusion. The one-time drop and permanent removal make this a map-milestone item rather than a farm target.

The seasonal event resource

A decorative pumpkin patch or snow crystal field placed on the map for a timed event. Removed from spawn tables after the event.

• Health 30 — 2 swings; accessible to all tool types
• Reward_ID references a custom event item (pumpkin, snow crystal)
• Reward_Min 1, Reward_Max 2 — light yield; event items are collectibles, not economy staples
• Reward_XP 3 — small XP reward
• Regrow 600 — 10-minute regrowth; event resources should feel abundant
• Vulnerable_To_All_Melee flag set — any weapon can harvest; accessibility is the priority

Place across the event zone via a temporary spawn table entry. Remove the spawn table entry when the event ends.

Authoring checklist

Before publishing a resource asset as part of a map or content mod, confirm the following:

• [ ] GUID is unique — generated fresh, separate from any item asset GUIDs
• [ ] ID is in the 50000+ range
• [ ] Type Resource is set (not Item or Object)
• [ ] Health is calibrated against the intended harvest tool's Damage_Resource
• [ ] Reward_ID references a loaded item (vanilla or custom)
• [ ] Reward_Min is less than or equal to Reward_Max
• [ ] Regrow is set to a positive value for renewable resources
• [ ] Requires_Harvest_Tool is set for resources that should require a specific tool type
• [ ] Resource prefab is assigned the Resource script component with the correct .dat GUID
• [ ] LOD Group is configured on the prefab (at least two LOD levels for frequently-placed nodes)
• [ ] Tested in single-player: node visible, takes damage from correct tool, drops correct items, regrows after timer
• [ ] Workshop description documents the resource type, intended harvesting tool, and expected yield
• [ ] Secondary reward fields (Reward_ID_2) are set if the resource drops a byproduct (sticks, pebbles)
• [ ] Reward_XP is set to a non-zero value to reward players for harvesting
• [ ] Map spawn table entry uses the correct resource GUID (not the prefab name or numeric ID)
• [ ] Hand-placed nodes are positioned on terrain surface with no floating or ground-clipping
• [ ] Explosion field is set to 0 for all standard trees and rocks (non-hazard resources)
• [ ] English.dat is authored with a Name field matching the intended in-game interact prompt text
• [ ] Vulnerable_To_All_Melee is set only for intentionally accessible resources; do not set alongside Requires_Harvest_Tool

Document history

Version	Date	Author	Notes
1.0	2025-05-18	57 Studios	Initial publication. Complete resource asset .dat reference, tree/rock/ore variants, harvest mechanics, map placement, FAQ, appendices.

Cross-references

• Melee Asset — the previous article; covers harvesting tools.
• Objects and Structures Assets — the next article.
• Project Folder Structure and GUIDs — GUID authoring.
• Master Bundle Export — Unity bundling pipeline.
• Smartly Dressed Games modding documentation — official field reference.
• Unturned on Steam — game page and community.