Prop data

From Valve Developer Community
Revision as of 08:29, 1 April 2008 by Beeswax (talk | contribs) (→‎Simple example: reverted example - clarity is important - please be more careful when editing other peoples work)
Jump to navigation Jump to search

Every model that is to be used by prop_physics (and some that are to be used by prop_dynamic) must have a prop_data block. The block is embedded with the QC command $keyvalues.

prop_data co-exists with, but is distinct from, $surfaceprop.

Note.pngNote:By default, models with prop_data cannot be prop_static.

Should my model be physical?

In Half-Life 2, Valve tried to follow these general rules:

If it's going to attach to or act as a support for a non-moving thing...
It should be static.
If it generates light...
It should be static.
If it's really big and the player couldn't possibly move it...
It should be static.
Otherwise...
It should be physical.

QC syntax example

$keyvalues
{
	prop_data
	{
		base			Wooden.Small 
		dmg.bullets		0 
		explosive_damage	100
		explosive_radius	50 
	}
}

Tips

You don't need to override anything at all if you don't want to
Just set a base and you've got a working physics prop.
Don't override health levels in all your props
Instead, use the base prop classes and let them set the health. This way you won't have one chair that takes twice as much damage as every other chair.
Whenever possible, avoid mixing material types inside the same prop
Don't make half-metal, half-wood props.
Follow Valve's rules above unless you have good reason to change them
In addition: Valve consider metal and plastic invulnerable, but everything else breakable.
Avoid collecting multiple objects into the same prop
Especially if you or Valve individually simulate identical-looking objects elsewhere.
Avoid moving parts and materials Source doesn't simulate
Don't hang coats from a coat rack or put water in a physical fish tank.

Options

General

base <choices>
Defines the physical properties of the prop, according to the material from which it is made. All other keyvalues override those inherited from this!
See prop_data base material guidelines for a list of Valve's stock prop_data types.
health <integer>
The amount of damage this prop should take before breaking.
Note.pngNote:It is the model's health attribute that determines whether or not it is breakable. If health is "0" or "" (null), the model does not take damage and is not breakable.
allowstatic <boolean>
Allow this model to be prop_static as well as prop_physics. For consistency, avoid using this.
physicsmode <choices>
Sets the physics mode used by prop_physics_multiplayer.
Number Name Description
1 Solid, Server-side Solid, pushes the player away.
2 Non-Solid, Server-side Non-solid, but gets pushed away by the player.
3 Non-Solid, Client-side Non-solid, clientside simulated only.
Template:Ep2 add
blockLOS <boolean>
Overrides whether the prop should block NPC Line of Sight. If unspecified, the game engine will decide based on the model's dimensions.
AIWalkable <boolean>
Set whether AI should try walking over this prop.
Todo: Does the prop type matter?

Damage modifiers

Use damage modifiers to reflect differences between the amount of damage that an object takes from different attacks. Don't use them to reflect overall damage strength. (e.g. Stone is resilient to everything. To reflect this, increase the health of all stone objects, don't set the damage modifiers lower.)

dmg.bullets <float>
Modifies damage done by bullets. Default is 1.0
  • Paper, Cloth and Glass Window = 0.5
  • Wood = 0.75
  • Flesh = 1.25.
dmg.club <float>
Modifies damage done by blunt impacts. Default is 1.0
  • Cloth = 0.75
  • Paper and Pottery = 1.25
  • Wood = 2.0
dmg.explosive <float>
Modifies damage done by explosions. Default is 1.0
  • Paper, Cloth, Pottery, Flesh and Wood = 1.5
damage_table <choices>
A Damage Table is defined by a programmer (in physics_impact_damage.cpp), and contains very detailed information about what damage a prop should take from different directions and forces. Only Glass and Pottery props inherit one; the others are used per-entity in C++ code.
Tip.pngTip:Use damage_table "" to ignore an inherited table.

Template:Damage table choices

Flammable props

fire_interactions is a sub-set of the prop_data $keyvalues that defines flammability. There are only three known parameters, each with only one known value: 

$keyvalues
{
	prop_data
	{
		fire_interactions
		{
			ignite			halfhealth // Will ignite on reaching 50% health
			explosive_resist	yes // Clamp blast damage so that the prop ignites instead of breaking
			flammable		yes // Can be ignited by fire and explosions
		}
	}
}

Exploding props

If these two fields are specified for a prop, then the prop will create an explosion with the specified values when it breaks. 

$keyvalues
{
	prop_data
	{
		health 1 			// health must be >0 for the prop to be breakable. 
		explosive_damage <float> 	// The amount of explosive damage done by this prop when it breaks. 
		explosive_radius <float> 	// The radius of the explosion caused by this prop when it breaks. 
	}
}

Gibs

The prop_data system handles generic gibs. Generic gibs are used for any breakable object that doesn't have custom gibs. Custom gibs are assigned to a model using the $collisiontext QC command.

breakable_model <choices>
Defines the set of generic gibs this prop should break into.
  • WoodChunks
  • GlassChunks
  • ConcreteChunks
  • MetalChunks
Only props with the Wood "base class" inherit a gibset (WoodChunks).
This is only necessary if the prop doesn't have custom gibs. In general custom gibs are far superior to generic ones, but of course, there's a limit to how many custom gibs you can fit into memory.
Generic Gibsets are defined at the bottom of mod/scripts/propdata.txt.
breakable_count <integer>
The number of generic breakable gibs to break into. Required for gibs to appear.
This allows you to hard-code the number gibs yourself. By default the game engine will attempt to attribute a sensible number of generic gib models within the volume of the breaking object, based upon their (and its) size.
Only props with the Wood "base class" inherit a gib count - ranging from Wood.Tiny = 0 through to Wood.Huge =10.
breakable_skin <integer>
The skin to use on the generic breakable models.
Allows you to specify a skin to use on the gib models, which is useful for matching the original prop's material.
Only props with the Wood "base class" inherit a gib skin (skin 0).
multiplayer_break <choices>
Determines whether the gibs from a prop_physics_multiplayer are simulated on the Client or Server or both.
Literal Value Description
both Creates gibs on both the server and the client.
server Only creates gibs on the server.
client Only creates gibs on the client. This is the default behavior.
Usually small gibs have no significant collision effect that might influence in-game events, so these are handled clientside rather than using up client-server connection bandwidth.
Todo: confirm that multiplayer_break is set for the breakable model rather than each individual gib itself.

Prototyping models

When working on prototypes, or when you don't have modellers handy, it's useful to be able to work around the prop data system's enforcement. To do this, use the prop_physics_override and prop_dynamic_override entities instead of prop_physics and prop_dynamic. A prop_physics_override entity will not remove itself if it is assigned a model that wants to be static (i.e. has no "prop_data" entry in its $keyvalues .QC section). It will also allow the level designer to set its "health".

The override entities allow you to temporarily use models incorrectly while prototyping, or waiting for a modeller to finish up a new model that has the properties you desire. It is highly recommended that you use Hammer's Entity Report feature to check each of your maps to ensure you have no override entities left when you ship them. Otherwise you may be shipping physics inconsistencies, and players are extremely quick to notice them (the orange bucket won't move when I shoot it on this level, but it did on the previous one).

propdata.txt

The purpose of the Prop Data system is to ensure that the interactive behavior of prop models stays consistent across all the levels in your game / mod. The three core prop entities (prop_static, prop_dynamic, and prop_physics) all use the prop data system to load game-related data from the model they're set to use. This section will explain how you can edit it in your mod.

The Prop Data system stores data hierarchically. The prop_data base classes are defined inside the mod\scripts\propdata.txt file. Wherever possible, models use one of these classes instead of defining their own class. This ensures a reasonable level of consistency in physics with models, and makes it easier to apply tweaks to the entire set of prop models without having to recompile each mdl. For example, in response to Half-Life 2 playtests, Valve tweaked the overall amount of health for all wooden objects in the game several times.

The propdata.txt format is a KeyValue formatted data file, where each entry matches the following format: 

<material_type>.<size_description> // Suggested format; you can actually call it anything you like (but avoid spaces)
{
	key	"value x or y" // If there is a space or tab character within a key or value, you need quote marks around it
	(...)
}

See also

Template:Otherlang:en Template:Otherlang:en:jp

Retrieved from "https://developer.valvesoftware.com/w/index.php?title=Prop_data&oldid=72654"