Pants Asset Reference

Intermediate40-60 minutesWindowsNotepad++Unity Editor

The pants asset is the data definition for every lower-body clothing item in Unturned™ - cargo pants, tactical pants, jeans, shorts, skirts, armored leggings, and any other item that occupies the Pants slot on the character model. The Pants slot is one of two clothing slots (alongside Shirt) that the ItemPantsAsset class in the Unturned™ runtime supports with both armor protection and storage capacity inherited from the ItemBagAsset base class. A well-authored pants asset with correctly tuned armor values and an appropriate storage grid dimension through Width and Height is the foundation of a functional lower-body clothing item in any mod catalog.

This article is the 57 Studios™ canonical reference for the pants asset subtype. It covers every .dat field applicable to the ItemPantsAsset class - the Armor damage reduction multiplier (shared with Shirt and Vest but independently configured), the Width and Height storage grid fields inherited from ItemBagAsset, the character skeleton bones that a pants prefab binds to, the legs slot assignment and how it interacts with the Vest slot's armor calculation, and the complete diagnostic table for pants-specific authoring errors. The shared identity fields common to every clothing type (ID, GUID, Type, Name, Rarity, Useable Clothing, Size_X, Size_Y) are documented in the base Clothing Asset Reference and are not repeated here except where pants-specific configuration departs from the norm.

Documentation source: This article references the official Smartly Dressed Games modding documentation chapter 55 (Pants Assets) for the ItemPantsAsset class definition and the parent ItemBagAsset class. Game-file evidence is drawn from the shipped pants under Bundles/Items/Pants/ in the vanilla Unturned™ asset set, including the Cargo_Pants, Cargo_Shorts, Corduroy_Pants, Coalition_Bottom, Coastguard_Bottom, Engineer_Bottom, Farmer_Bottom, Rain_Pants, and Biohazard_Bottom families.

Who this article is for

This article is written for Unturned™ mod authors who have completed at least one clothing mod or have read the Clothing Asset Reference and want to focus specifically on the Pants slot. You should already be familiar with the master bundle pipeline, the SkinnedMeshRenderer bone binding workflow, and the .dat authoring format. If you are new to Unturned™ clothing modding, start with Project Folder Structure and GUIDs and How to Install Unity Editor before returning here.

What you will learn

• The complete field surface of the ItemPantsAsset class: Armor, Width, and Height.
• Why pants inherit from ItemBagAsset and what that means for storage capability.
• How the Armor field works as a damage reduction multiplier and the armor stacking math across Shirt, Pants, and Vest slots.
• The Width and Height storage grid that pants can provide.
• The character skeleton bones that a pants prefab binds to, with exact bone names required for correct deformation.
• Inventory footprint guidelines by pants type.
• The complete diagnostic table for pants-specific authoring errors.
• Why pants have no unique slot-specific fields beyond those inherited from parent classes.

How the pants slot works

The Pants slot covers the player's pelvis, thighs, and shins. When a player equips a pants item, the runtime binds the item's prefab to the character skeleton pelvis and leg bones, applies the Armor multiplier to incoming damage calculations, and creates a wearable storage grid from Width and Height (if both are set to non-zero values).

The Pants slot is independent of the Shirt and Vest slots. All three slots can be worn simultaneously. The pants armor value contributes to the three-way multiplicative armor stack.

Storage inheritance from ItemBagAsset

Pants inherit from ItemBagAsset, the same base class that provides storage grids for backpack and shirt items. This inheritance means pants can define a storage grid through Width and Height fields. The storage grid created by pants functions identically to a backpack grid, providing additional inventory slots while the pants are equipped.

The shipped Unturned™ asset set includes many pants with storage capacity. The Cargo_Pants (ID 209) provides a 6x3 grid (18 slots). The Coalition_Bottom (ID 1419) provides a 4x3 grid (12 slots). The Farmer_Bottom (ID 243) provides a 4x3 grid (12 slots). Pants storage is a fully supported vanilla feature, not a mod extension.

Pants .dat field reference

Identity and shared fields

Pants items require the same shared identity fields as every other item type, documented in full in Item Asset Anatomy and Clothing Asset Reference.

Field	Type	Example	Notes
ID	uint16	42401	Unique item ID. Use 42400+ range per 57 Studios™ allocation or 50000+ for open community range.
GUID	uint128 hex	b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3	128-bit globally unique identifier. Generate fresh per item.
Type	enum	Pants	Must be Pants for pants slot items.
Name	string	MyTacticalPants	Internal name. Used in console commands and cross-reference.
Rarity	enum	Uncommon	Common, Uncommon, Rare, Epic, Legendary, Mythical.
Useable	enum	Clothing	Must be Clothing for all wearable items.
Size_X	uint8	2	Inventory grid width un-equipped.
Size_Y	uint8	2	Inventory grid height un-equipped.
Size_Z	float	0.65	Visual depth scaling for the item icon.

Armor field

Field	Type	Range	Default	Purpose
Armor	float	0.0 to 1.0	1.0	Damage multiplier when equipped. Lower values = more protection. 1.0 = no protection. 0.9 = 10% damage reduction. 0.8 = 20% reduction.

The Armor field semantics are identical to the Shirt slot's Armor. The field is a damage multiplier - incoming damage is multiplied by the Armor value. An Armor value of 0.9 produces 10% damage reduction; 0.85 produces 15% reduction; 1.0 produces zero reduction. The pants armor value applies independently of shirt and vest armor, and all three stack multiplicatively.

Storage fields (inherited from ItemBagAsset)

Field	Type	Range	Default	Purpose
Width	uint8	0-255 (practical 0-10)	0	Number of columns in the pants' storage grid. A value of 0 means no horizontal storage.
Height	uint8	0-255 (practical 0-8)	0	Number of rows in the pants' storage grid. A value of 0 means no vertical storage.

The Width and Height fields are inherited from ItemBagAsset, providing storage capability identical to shirt and backpack storage. The default value for both fields is 0. When both are 0 (or both are absent), the pants provide zero storage slots. Setting only one of the two fields also produces zero storage because the grid area calculation 0 x N = 0 applies.

No unique pants-specific fields

Per the SDG documentation, ItemPantsAsset has no unique asset properties. All .dat fields applicable to pants items are inherited from parent classes - Armor from ItemClothingAsset, Width and Height from ItemBagAsset, and the identity fields from ItemAsset. This means the pants .dat is the simplest of the three armor-capable clothing slots (Shirt, Pants, Vest), with no Ignore_Hand flag, no character mesh replacement fields, and no Hat_Type equivalent.

Pants vs. shorts

The Pants slot covers both full-length pants and shorts. There is no separate Shorts asset type in the Unturned™ runtime - shorts are authored as Type Pants items with a shorter leg mesh prefab. The .dat fields are identical. The visual distinction between pants and shorts is in the prefab mesh length, not in the .dat configuration.

Shipped shorts items (Cargo_Shorts ID 227, Corduroy_Shorts ID 228) use Type Pants and carry the same Armor and Width/Height fields as full-length pants. The English.dat display name communicates the item's visual category to the player.

File and folder structure

A complete pants mod requires the following files:

Workshop/Content/304930/<modID>/
├── Bundles/
│   └── <BundleName>.unity3d              ← master bundle containing the pants prefab
└── Items/
    └── MyPants/
        ├── MyPants.dat                   ← primary configuration (fields documented here)
        └── English.dat                   ← display name and description

Armor value balance reference

Armor value	Effective damage reduction	Vanilla equivalent examples
1.0	0% (no protection)	Aprix_Bottom, Astronaut_Bottom, Blueknight_Bottom - cosmetic pants
0.95	5%	Biohazard_Bottom, Chef_Bottom, Cargo_Pants, Engineer_Bottom, Rain_Pants, Corduroy_Pants - standard pants
0.9	10%	Coalition_Bottom, Coastguard_Bottom - military-grade pants
0.85	15%	SpecOps_Bottom - special operations pants
0.8	20%	Heavy armored pants - cohort-recommended maximum

Storage grid dimension reference

Pants type	Width	Height	Total slots	Vanilla examples
No storage (cosmetic only)	0 or absent	0 or absent	0	Aprix_Bottom, Astronaut_Bottom, Detective_Bottom, Festive_Bottom
Light cargo	4	3	12	Coalition_Bottom, Coastguard_Bottom, Engineer_Bottom, Farmer_Bottom
Standard cargo	5	2	10	Biohazard_Bottom, Chef_Bottom, Diving_Bottom
Heavy cargo	5	3	15	Cargo_Shorts, Corduroy_Shorts
Tactical cargo	6	3	18	Cargo_Pants
Specialized	4	3	12	Rain_Pants

Armor stacking across Shirt, Pants, and Vest

The pants Armor value is one part of a three-way multiplicative stack with the Shirt and Vest slots:

Total multiplier = Shirt Armor x Pants Armor x Vest Armor

Example stacking scenarios for pants

Scenario	Shirt Armor	Pants Armor	Vest Armor	Total multiplier	Effective reduction
Cosmetic	1.0	1.0	1.0	1.0	0%
Light	0.95	0.95	0.95	~0.857	~14.3%
Standard military	0.9	0.9	0.9	0.729	~27.1%
Pants heavy only	1.0	0.85	1.0	0.85	15%
Full tactical	0.85	0.85	0.85	~0.614	~38.6%
Max practical	0.8	0.8	0.8	0.512	~48.8%

The armor stacking diagram above traces the full three-slot chain. The pants' Armor value is the middle step in this chain, applying after the shirt modifier and before the vest modifier. Changing the pants Armor value alone shifts the intermediate value that passes to the vest calculation.

Character skeleton binding for pants

A pants prefab binds to the character skeleton pelvis and leg bones. The SkinnedMeshRenderer on the pants prefab must reference these bones by their exact names.

Required bones for pants binding

Bone name	Region	Required
Character_Hips	Pelvis / hips	Yes
Character_LeftUpLeg	Left thigh	Yes
Character_LeftLeg	Left shin	Yes
Character_RightUpLeg	Right thigh	Yes
Character_RightLeg	Right shin	Yes

Optional bones for extended coverage

Bone name	Region	When needed
Character_Spine	Lower spine	For high-waisted pants that extend above the natural waistline

The pants mesh should be weighted smoothly between the pelvis and thigh bones at the hip joint. Weight bleeding between Character_Hips and Character_LeftUpLeg (and symmetrically for the right side) is essential for natural deformation when the player walks, runs, and crouches. A common weight-painting error is under-weighting the hip-to-thigh transition, producing a visible seam at the hip when the leg moves.

Pants prefab hierarchy

The minimum structure for a pants prefab:

MyPantsPrefab (root)
└── Body (SkinnedMeshRenderer - pants mesh)
    └── Material (assigned to the SkinnedMeshRenderer)

Mesh authoring considerations for pants

The pants mesh must be modeled to fit the Unturned™ character legs. The cohort-recommended workflow mirrors the shirt workflow:

1. Import the character lower-body reference FBX into Blender.
2. Model the pants mesh approximately 1-3mm outside the leg and pelvis surfaces.
3. Parent the pants mesh to the character armature using Armature Deform with Automatic Weights.
4. Inspect weight paint at the hip joint - confirm smooth transition between pelvis and thigh bone weights.
5. Confirm the pants mesh does not intersect the leg surfaces - intersecting faces produce z-fighting artifacts.
6. Apply scale and rotation before FBX export.
7. Export FBX with the correct axis settings for Unity import.
8. In Unity, assign the SkinnedMeshRenderer bone references to the five required leg bones.
9. Create the prefab, assign the material, set the AssetBundle name, and build the master bundle.

Inventory footprint guidelines

Pants type	Size_X	Size_Y	Rationale
Shorts	2	2	Lower fabric volume
Light pants (jeans, chinos)	2	2	Standard pants bulk
Cargo pants	2	2	Standard pants bulk with extra pockets
Heavy armor pants	2	2	Standard - armored bulk does not necessarily increase inventory footprint

The inventory footprint for pants is consistently 2 x 2 across the shipped vanilla set. Cargo_Pants, Corduroy_Pants, Engineer_Bottom, Farmer_Bottom, Rain_Pants, and Coalition_Bottom all use Size_X 2, Size_Y 2. The cohort recommendation is to stay with 2 x 2 for all pants items unless the item is exceptionally bulky (full leg armor plating, oversized snow pants extending beyond normal leg volume).

Pants in the class inheritance chain

ItemAsset (base item properties: ID, GUID, Name, Rarity, Size_X, Size_Y)
  └── ItemClothingAsset (clothing properties: Useable Clothing, Armor, slot behavior)
      └── ItemBagAsset (Width, Height - storage grid fields)
          └── ItemPantsAsset (Type Pants - no unique fields)

The ItemPantsAsset class inherits from ItemBagAsset, the same base class that shirts and backpacks use. This means pants have access to the same storage grid system. The ItemPantsAsset class has no unique fields - all its configuration comes from its parent classes. This is documented in the SDG chapter for pants assets: "Pants have no unique asset properties. Refer to parent classes for additional properties."

Complete .dat example: tactical cargo pants with storage

ID 42401
GUID b8c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3
Type Pants
Name MyTacticalPants
Rarity Uncommon
Size_X 2
Size_Y 2
Size_Z 0.65
Useable Clothing

Armor 0.9
Width 6
Height 3

Companion English.dat:

Name Tactical Cargo Pants
Description Heavy-duty cargo pants with 18 storage slots and standard ballistic protection. Multiple pocket configuration for extended field operations.

Complete .dat example: cosmetic jeans (no armor, no storage)

ID 42402
GUID c9d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4
Type Pants
Name MyCasualJeans
Rarity Common
Size_X 2
Size_Y 2
Size_Z 0.65
Useable Clothing

Armor 1.0

Companion English.dat:

Name Casual Jeans
Description Comfortable civilian jeans. Provides no storage or protection.

Complete .dat example: light shorts (no storage, light armor)

ID 42403
GUID d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5
Type Pants
Name MyTacticalShorts
Rarity Common
Size_X 2
Size_Y 2
Size_Z 0.65
Useable Clothing

Armor 0.95

Companion English.dat:

Name Tactical Shorts
Description Lightweight tactical shorts with basic protection. Ideal for warm-weather operations.

Complete .dat example: utility pants with light storage

ID 42404
GUID e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5b6
Type Pants
Name MyUtilityPants
Rarity Common
Size_X 2
Size_Y 2
Size_Z 0.65
Useable Clothing

Armor 0.95
Width 4
Height 3

Companion English.dat:

Name Utility Pants
Description Light utility pants with 12 storage slots and basic protection. Standard-issue patrol bottoms.

Diagnostic table

Symptom	Most likely cause	Resolution
Pants equips to wrong slot	Type field is not Pants	Set Type Pants
Pink material on pants	Material not assigned in Unity	Assign material, rebuild bundle
Pants are static, do not deform with character	MeshRenderer used instead of SkinnedMeshRenderer	Replace with SkinnedMeshRenderer, re-bind bones
Pants deform incorrectly at hip	Bone weight paint missing smooth transition at hip joint	Re-weight the mesh; blend Character_Hips to Character_LeftUpLeg / Character_RightUpLeg
Pants deform incorrectly at knee	Leg bone references misspelled in Unity	Verify Character_LeftLeg, Character_RightLeg spelling
Armor has no effect	Armor 1.0 means zero protection	Lower Armor value below 1.0
Pants provide no storage despite having fields	Only Width or only Height set - one is 0	Set both Width and Height to positive values
Storage grid on pants is wrong size	Width x Height calculation off	Check both values; recalculate total
Pants invisible when equipped	Prefab GUID mismatch	Confirm GUID in .dat matches prefab GUID in Unity bundle
Pants clip through character leg surface	Mesh modeled too close to leg or inside leg surface	Refit mesh 1-3mm outside leg surface
Z-fighting between pants and vest	Shirt/Pants/Vest meshes overlap at waist	Adjust mesh boundaries at waist line
Item cannot be picked up	Useable Clothing field missing	Add Useable Clothing
Pants incorrectly identified as shorts in-game	No distinction at .dat level - visual is prefab-driven	Confirm prefab mesh is correct length
Pants storage grid appears separate from shirt grid	Each slot provides independent grids	Expected behavior - shirt and pants grids are separate inventory regions

English.dat localization for pants

The English.dat description should communicate the pants' armor tier and storage capacity. The cohort-recommended patterns:

Pants configuration	Description pattern	Example
Cosmetic only (Armor 1.0, no storage)	"Comfortable [type]. Provides no storage or protection."	"Comfortable civilian jeans. Provides no storage or protection."
Armor only (no storage)	"Provides [tier] leg protection."	"Light tactical pants with basic ballistic leg protection."
Storage only (no armor)	"Provides [N] pocket storage slots."	"Utility pants with 12 pocket storage slots for tools and supplies."
Both armor and storage	"Provides [tier] protection and [N] storage slots."	"Heavy cargo pants with 18 storage slots and standard ballistic protection."
Shorts (any config)	Prefix item name with "Shorts" in display name, adjust length description	"Lightweight tactical shorts with basic protection. Ideal for warm-weather operations."

Pants authoring checklist

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

• [ ] Type Pants is set correctly.
• [ ] Armor value is below 1.0 if protection is intended; Armor 1.0 for cosmetic-only pants.
• [ ] Width and Height are both set to positive values if storage is intended; both absent (or 0) for cosmetic-only.
• [ ] Bone references include Character_Hips, Character_LeftUpLeg, Character_LeftLeg, Character_RightUpLeg, Character_RightLeg.
• [ ] Hip joint weight paint is smooth - no visible seam at the hip crease.
• [ ] Pants mesh sits 1-3mm outside the character leg surface to prevent z-fighting.
• [ ] English.dat communicates the armor tier and storage capacity accurately.
• [ ] Tested in-game: pants visible, deform with leg movement, armor applies, storage grid appears (if configured).

Best practices

• Tune pants Armor in coordination with the Shirt and Vest armor values for the same item set. Pants at 0.9 with Shirt at 0.9 produces a balanced two-slot combination.
• Use pants storage intentionally. The Cargo_Pants pattern (18 slots) is the cohort benchmark for maximum pants storage. Smaller pockets on utility pants should use 12 slots (4x3).
• Model the pants mesh to the correct length. A prefab that ends above the knee is shorts regardless of the item's display name; a prefab that extends to the ankle is pants. The prefab mesh is the only visual distinction.
• Apply scale in Blender before FBX export. Non-unit scale produces incorrect leg positioning.
• Keep the pants inventory footprint at Size_X 2, Size_Y 2 unless the item is exceptionally bulky. The shipped vanilla set is uniformly 2 x 2.
• Test armor stacking across all three armor-capable slots (Shirt, Pants, Vest) in-game. The multiplicative stacking means combined protection can be significantly higher than any single piece suggests.

Frequently asked questions

Can a pants item provide both Armor and Width/Height storage?

Yes. The Armor field and the Width/Height fields are independent and can be set simultaneously. The shipped Cargo_Pants (ID 209) demonstrates this pattern with Armor 0.95, Width 6, Height 3. The Coalition_Bottom (ID 1419) uses Armor 0.9, Width 4, Height 3.

What is the difference between Width/Height on pants and Storage_X/Storage_Y on vests?

Width and Height are defined on ItemBagAsset, the same class that provides storage to shirts and backpacks. Storage_X and Storage_Y are defined on ItemClothingAsset specifically for vest items. The two field pairs have the same semantics (column count and row count) and the same data type (uint8), but they are defined on different classes and read by different code paths. Pants must use Width and Height. Vest items must use Storage_X and Storage_Y.

Why do pants have no unique fields?

The SDG documentation explicitly states that ItemPantsAsset has no unique asset properties. The class exists as a concrete implementation of ItemBagAsset that targets the Pants slot. All fields that apply to pants are inherited from parent classes. This design simplicity means pants .dat files are the smallest and least error-prone among the clothing items.

How do I author shorts?

Author shorts as Type Pants with a prefab mesh that ends above the knee. No .dat field distinguishes pants from shorts. The visual distinction is entirely in the prefab mesh length. Set the English.dat display name to include "Shorts" for player clarity.

Can pants have Ignore_Hand like shirts can?

No. The Ignore_Hand flag is a ItemShirtAsset-specific field. Pants do not have this field. The pants mesh mirrors normally in left-handed mode with no override available.

What is the maximum storage grid a pants item can provide?

The theoretical maximum for Width and Height is 255 each (uint8), but the practical maximum is constrained by the inventory UI. Width values above 10 and Height values above 8 produce grids that clip outside the inventory panel bounds. The cohort recommendation is to keep Width at or below 6 and Height at or below 4 for pants storage.

Does the pants Armor value affect leg-specific damage only?

No. The Armor field on pants applies to all incoming damage regardless of which body region is hit. Unturned™ does not have regional armor hitboxes. A single Armor value applies to the entire character when the pants are equipped, stacking multiplicatively with Shirt and Vest armor values.

How do I make cosmetic-only pants?

Set Armor 1.0 (or omit the field, which defaults to 1.0). Omit Width and Height entirely (or set both to 0). The pants will equip, display the prefab mesh, and provide no functional benefit beyond appearance.

Can pants have character mesh replacement like shirts can?

No. The character mesh replacement fields (Has_1P_Character_Mesh_Override, Character_Mesh_3P_Override_LODs, Has_Character_Material_Override) are specific to ItemShirtAsset. Pants items cannot replace the character body mesh. Any leg geometry modification must be achieved through the pants prefab mesh alone.

Do I need a separate .dat field for pocket storage vs. backpack storage?

No. The Width and Height fields create a single storage grid. There is no distinction between "pocket storage" and "backpack storage" at the .dat level - the same fields define the grid regardless of the item's visual category. The description in English.dat is the mechanism for communicating the storage context to the player.

What happens if I set Width to 0 and Height to a positive value on pants?

The grid area calculation 0 x positive = 0 applies. The pants will equip correctly and the prefab will be visible, but the storage grid will have zero usable slots. Both Width and Height must be set to positive values for functional storage.

How many inventory grid regions can a player have simultaneously?

A player can have up to four independent inventory grid regions simultaneously: the main inventory, the backpack grid (from an equipped backpack), the vest grid (from an equipped vest with Storage_X/Storage_Y), and the pants grid (from equipped pants with Width/Height). A configured shirt can add a fifth region. Each region is independent and rendered in its own panel.

Advanced considerations

Pants in the RP server context

In RP servers, pants are often the secondary armor item (after shirts) and the primary storage item for non-combat roles. A paramedic's pants might have high storage (18 slots) but minimal armor (0.95). A frontline combat soldier's pants might have moderate armor (0.85) but limited storage (10-12 slots). The cohort recommendation is to differentiate roles through the pants Width/Height and Armor combination rather than through unique fields - pants have no role-specific fields, so the tuning of inherited fields is the only lever.

Pants balance for survival servers

On survival servers, pants storage is a meaningful balance lever because the pants grid is always accessible when equipped (unlike the backpack grid, which requires a backpack item). Pants with Width 6 and Height 3 (18 slots) provide a significant inventory expansion that does not require a separate item. The cohort recommendation for survival servers is to reserve high-capacity pants for mid-to-late game progression and to keep early-game pants cosmetic-only or light-storage.

Pants mesh authoring for multiple poses

The pants mesh must deform correctly across the full range of character animations - walking, running, crouching, swimming, climbing. At the hip joint, the mesh must accommodate a 90-degree leg lift without visible distortion. At the knee, the mesh must accommodate a 120-degree bend without the mesh collapsing into itself at the back of the knee. The cohort-recommended technique is to pose the character reference in a running pose (one leg forward, one leg back) during mesh authoring and to inspect the mesh deformation at the extreme joint angles before finalizing the weight paint.

Appendix A: Complete pants field quick reference

Field	Type	Source class	Required	Default	Notes
ID	uint16	ItemAsset	Yes	-	Unique item ID
GUID	uint128 hex	ItemAsset	Yes	-	128-bit globally unique identifier
Type	enum	ItemClothingAsset	Yes	-	Must be Pants
Name	string	ItemAsset	Yes	-	Internal name
Rarity	enum	ItemAsset	No	Common	Rarity tier
Useable	enum	ItemClothingAsset	Yes	-	Must be Clothing
Size_X	uint8	ItemAsset	Yes	-	Inventory width
Size_Y	uint8	ItemAsset	Yes	-	Inventory height
Size_Z	float	ItemAsset	No	Engine default	Visual scaling
Armor	float	ItemClothingAsset	Recommended	1.0	Damage multiplier
Width	uint8	ItemBagAsset	No	0	Storage grid width - inherited from bag
Height	uint8	ItemBagAsset	No	0	Storage grid height - inherited from bag
Pro	bool	ItemAsset	No	False	PRO/Gold gating
Bypass_ID_Limit	bool	ItemAsset	No	-	Bypass ID limit for high IDs
Proof_Water	bool	ItemClothingAsset	No	-	Water damage immunity
Proof_Fire	bool	ItemClothingAsset	No	-	Fire damage immunity
Proof_Radiation	bool	ItemClothingAsset	No	-	Radiation damage immunity

Appendix B: Pants storage grid comparison table

Width	Height	Total slots	Example vanilla pants
0	0	0	Aprix_Bottom, Astronaut_Bottom, Detective_Bottom, Festive_Bottom
4	3	12	Coalition_Bottom, Coastguard_Bottom, Engineer_Bottom, Farmer_Bottom, Corduroy_Pants, Rain_Pants
5	2	10	Biohazard_Bottom, Chef_Bottom, Diving_Bottom
5	3	15	Cargo_Shorts, Corduroy_Shorts
6	3	18	Cargo_Pants

Appendix C: Armor value comparison across vanilla pants

Pants item	ID	Armor value	Width	Height	Notes
Aprix_Bottom	808	none (1.0)	none	none	Cosmetic
Astronaut_Bottom	559	none (1.0)	none	none	Cosmetic
Biohazard_Bottom	1016	0.95	5	2	Utility
Cargo_Pants	209	0.95	6	3	Heavy cargo
Cargo_Shorts	227	0.95	5	3	Shorts variant
Chef_Bottom	231	0.95	5	2	Professional
Coalition_Bottom	1419	0.9	4	3	Military
Coastguard_Bottom	1463	0.9	4	3	Military
Corduroy_Pants	213	0.95	4	3	Casual
Diving_Bottom	1180	0.95	5	2	Specialist
Engineer_Bottom	408	0.95	4	3	Professional
Farmer_Bottom	243	0.95	4	3	Rural
Rain_Pants	1995	0.95	4	3	Weather gear

Cross-references

• Shirt Asset Reference - the previous article; covers the Shirt slot which shares ItemBagAsset inheritance and storage via Width/Height.
• Vest Asset Reference - the next article; covers the Vest slot which uses Storage_X/Storage_Y instead of Width/Height.
• Clothing Asset Reference - the base clothing reference for shared fields, armor stacking, and slot behavior.
• Bag Asset Reference - the ItemBagAsset base class reference that documents the Width and Height storage fields inherited by pants.
• Hat Asset Reference - the first article in the clothing chain; covers the Hat slot with ItemGearAsset inheritance.
• Project Folder Structure and GUIDs - item folder layout and GUID authoring.
• Item Asset Anatomy - the universal shared field reference for every item type.
• How to Export an FBX - the FBX export workflow for clothing meshes.
• Master Bundle Export - the Unity bundling workflow for pants prefabs.
• Steam Workshop Submission - publishing workflow for full clothing mods.
• Smartly Dressed Games modding documentation - official field reference for ItemPantsAsset and parent classes.
• Unturned on Steam - game page and community.

Document history

Version	Date	Author	Notes
1.0	2026-07-26	57 Studios	Initial publication. Complete pants asset field reference, Armor mechanics, Width/Height storage grid, character skeleton binding, diagnostic tables, worked examples.