cod2-sdk/deffiles/bulletweapon.gdf

#name "bulletweapon"
#dll "all" "configstringconvert"
#target_dir "weapons/sp/" // target location 1 (single-player)
#target_dir "weapons/mp/" // target location 2 (multi-player)
#file_ext "*"
#version 23

// This tells the configstring converter what the file type identifier should be
enum { "WEAPONFILE" } configstringFileType

// This uses the config string convert's multi-target folder
// mechanism to make the weapon either a single-player weapon
// or a multi-player weapon.
// The first character is used to specify which target folder to go in
enum { "1: Single-Player", "2: Multi-Player" } targetFolder

string displayName
string modeName
enum { "none", "other", "springfield", "bar", "mp40", "thompson", "sten", "bren", "kar98k", "m1carbine", "enfield" } playerAnimType
string altWeapon
string AIOverlayDescription

enum { "bullet", "binoculars" } weaponType
enum { "rifle", "mg", "smg", "pistol", "item", "spread" } weaponClass
enum { "primary", "none" } weaponSlot

int 1 0 1 twoHanded
int 1 0 1 rifleBullet
int 0 0 1 armorPiercing
int 0 0 1 semiAuto
int 0 0 1 boltAction
int 0 0 1 aimDownSight
int 1 0 1 rechamberWhileAds
int 0 0 1 noPartialReload
int 0 0 1 segmentedReload
int 1 0 1 wideListIcon
int 1 0 1 wideKillIcon
int 1 0 1 flipKillIcon

float 1600 0 50000 autoAimRange
float 50000 0 50000 slowdownAimRange
float 50000 0 50000 slowdownAimRangeAds
float 50000 0 50000 lockonAimRange
float 50000 0 50000 lockonAimRangeAds

float 1600 0 10000 enemyCrosshairRange
float 1 0 5 moveSpeedScale
int 30 0 80 gunMaxPitch
int 30 0 80 gunMaxYaw

string ammoName
int 100 0 999 maxAmmo
int 0 0 1000 startAmmo
string clipName
int 10 0 999 clipSize
int 1 1 20 shotCount
int 0 0 999 dropAmmoMin
int 0 0 999 dropAmmoMax
int 0 0 999 reloadAmmoAdd
int 0 0 999 reloadStartAdd

int 30 0 1000 damage
int 30 0 1000 minDamage
int 25 0 1000 meleeDamage
float 15000 1 15000 maxDamageRange
float 16000 1 16000 minDamageRange

float 1.0 0 10 locNone
float 4.0 0 10 locHelmet
float 4.0 0 10 locHead
float 5.0 0 10 locNeck
float 1.0 0 10 locTorsoUpper
float 0.9 0 10 locTorsoLower
float 0.8 0 10 locRightArmUpper
float 0.6 0 10 locRightArmLower
float 0.4 0 10 locRightHand
float 0.8 0 10 locLeftArmUpper
float 0.6 0 10 locLeftArmLower
float 0.4 0 10 locLeftHand
float 0.8 0 10 locRightLegUpper
float 0.6 0 10 locRightLegLower
float 0.4 0 10 locRightFoot
float 0.8 0 10 locLeftLegUpper
float 0.6 0 10 locLeftLegLower
float 0.4 0 10 locLeftFoot
float 0 0 10 locGun

float 0.1 0.0 10.0 fireTime
float 0.1 0 10.0 fireDelay
float 0.7 0.0 10.0 meleeTime
float 0.25 0.05 10.0 meleeDelay
float 2.0 0.0 10.0 reloadTime
float 2.0 0.0 10.0 reloadEmptyTime
float 0 0.0 10.0 reloadStartTime
float 0 0.0 10.0 reloadEndTime
float 0 0.0 10.0 reloadAddTime
float 0 0.0 10.0 reloadStartAddTime
float 0.1 0.0 10.0 rechamberTime
float 0 0.0 10.0 rechamberBoltTime
float 0.5 0.0 10.0 dropTime
float 0.5 0.0 10.0 raiseTime
float 0.5 0.0 10.0 altDropTime
float 0.5 0.0 10.0 altRaiseTime
float 0.5 0.0 10.0 quickDropTime
float 0.5 0.0 10.0 quickRaiseTime

float 0 -300 300 standMoveF
float 1 -300 300 standMoveR
float -1.5 -300 300 standMoveU
float 0 -300 300 standRotP
float 0 -300 300 standRotY
float 0 -300 300 standRotR
float 110 0 3000 standMoveMinSpeed
float 110 0 1000 standRotMinSpeed
float 4 0 300 posMoveRate
float 5 0 300 posRotRate

float 0 -300 300 duckedMoveF
float 1 -300 300 duckedMoveR
float -1.5 -300 300 duckedMoveU
float 0 -300 300 duckedRotP
float 0 -300 300 duckedRotY
float 0 -300 300 duckedRotR
float -2 -300 300 duckedOfsF
float 2 -300 300 duckedOfsR
float -0.2 -300 300 duckedOfsU
float 60 0 3000 duckedMoveMinSpeed
float 60 0 1000 duckedRotMinSpeed

float 0 -300 300 proneMoveF
float 1 -300 300 proneMoveR
float -1.5 -300 300 proneMoveU
float 0 -300 300 proneRotP
float 0 -300 300 proneRotY
float 0 -300 300 proneRotR
float -6 -300 300 proneOfsF
float 3.5 -300 300 proneOfsR
float 0.8 -300 300 proneOfsU
float 10 0 300 posProneMoveRate
float 10 0 300 posProneRotRate
float 0 0 3000 proneMoveMinSpeed
float 0 0 1000 proneRotMinSpeed

int 80 0 150 hipIdleAmount
int 25 0 150 adsIdleAmount
float 1.0 0 100 hipIdleSpeed
float 1.0 0 100 adsIdleSpeed
float 0.5 0 1 idleCrouchFactor
float 0.15 0 1 idleProneFactor

float 0 0 10 adsSpread
float 0 -30 30 adsAimPitch
float 0.3 0 10 adsTransInTime
float 0.6 0 10 adsTransOutTime
float 0.1 0 5 adsTransBlendTime
float 0.6 0 5 adsReloadTransTime
float 1 0 1 adsCrosshairInFrac
float 0.2 0 1 adsCrosshairOutFrac
float 65 10 160 adsZoomFov
float 0.5 0 1 adsZoomInFrac
float 0.1 0 1 adsZoomOutFrac
float 1.0 0 10 adsBobFactor
float 0 0 100 adsViewBobMult
float 0 0 90 adsViewErrorMin
float 0 0 90 adsViewErrorMax

float 4 0 90 hipSpreadStandMin
float 3 0 90 hipSpreadDuckedMin
float 2 0 90 hipSpreadProneMin

float 10 0 90 hipSpreadMax
float 10 0 90 hipSpreadDuckedMax
float 10 0 90 hipSpreadProneMax

float 0.25 0 1 hipSpreadFireAdd
float 0 0 10 hipSpreadTurnAdd
float 0 0 10 hipSpreadMoveAdd
float 1.5 0 50 hipSpreadDecayRate
float 1.375 0 10 hipSpreadDuckedDecay
float 1.6 0 10 hipSpreadProneDecay

int 4 0 100 hipGunKickReducedKickBullets
float 20 0 100 hipGunKickReducedKickPercent
float -5 -100 100 hipGunKickPitchMin
float -3 -100 100 hipGunKickPitchMax
float -15 -100 100 hipGunKickYawMin
float 15 -100 100 hipGunKickYawMax
float 250 0 1000 hipGunKickAccel
float 500 0 10000 hipGunKickSpeedMax
float 15 0 100 hipGunKickSpeedDecay
float 1 0 100 hipGunKickStaticDecay
int 4 0 100 adsGunKickReducedKickBullets
float 20 0 100 adsGunKickReducedKickPercent
float -30 -100 100 adsGunKickPitchMin
float -20 -100 100 adsGunKickPitchMax
float -17 -100 100 adsGunKickYawMin
float 17 -100 100 adsGunKickYawMax
float 250 0 1000 adsGunKickAccel
float 1000 0 10000 adsGunKickSpeedMax
float 10 0 100 adsGunKickSpeedDecay
float 1 0 100 adsGunKickStaticDecay

float 20 -100 100 hipViewKickPitchMin
float 40 -100 100 hipViewKickPitchMax
float -15 -100 100 hipViewKickYawMin
float 15 -100 100 hipViewKickYawMax
float 2000 10 10000 hipViewKickCenterSpeed
float 20 -200 200 adsViewKickPitchMin
float 95 -200 200 adsViewKickPitchMax
float -10 -200 200 adsViewKickYawMin
float 30 -200 200 adsViewKickYawMax
float 2000 10 10000 adsViewKickCenterSpeed

float 30 0 180 swayMaxAngle
float 6 1 50 swayLerpSpeed
float 0.1 -2 2 swayPitchScale
float 0.1 -2 2 swayYawScale
float 0.1 -2 2 swayHorizScale
float 0.1 -2 2 swayVertScale
float 5 0 20 swayShellShockScale
float 30 0 180 adsSwayMaxAngle
float 6 1 50 adsSwayLerpSpeed
float 0.1 -2 2 adsSwayPitchScale
float 0.1 -2 2 adsSwayYawScale
float 0.1 -2 2 adsSwayHorizScale
float 0.1 -2 2 adsSwayVertScale

float 720 1 100000 fightDist
float 1400 1 100000 maxDist
string aiVsAiAccuracyGraph
string aiVsPlayerAccuracyGraph

string reticleCenter
string reticleSide
int 32 1 480 reticleCenterSize
int 16 1 480 reticleSideSize
int	0 0 480 reticleMinOfs
float 0 0 1 hipReticleSidePos

string adsOverlayShader
enum { "none", "crosshair", "FG42", "Springfield", "binoculars" } adsOverlayReticle
int 320 1 640 adsOverlayWidth
int 240 1 480 adsOverlayHeight

string gunModel
string handModel
string worldModel

string idleAnim
string emptyIdleAnim
string fireAnim
string lastShotAnim
string rechamberAnim
string meleeAnim
string reloadAnim
string reloadEmptyAnim
string reloadStartAnim
string reloadEndAnim
string raiseAnim
string dropAnim
string altRaiseAnim
string altDropAnim
string quickRaiseAnim
string quickDropAnim
string adsFireAnim
string adsLastShotAnim
string adsRechamberAnim
string adsUpAnim
string adsDownAnim

string viewFlashEffect
string worldFlashEffect
string shellEjectEffect
string lastShotEjectEffect

string pickupSound
string ammoPickupSound
string fireSound
string fireSoundPlayer
string lastShotSound
string lastShotSoundPlayer
string meleeSwipeSound
string rechamberSound
string rechamberSoundPlayer
string reloadSound
string reloadSoundPlayer
string reloadEmptySound
string reloadEmptySoundPlayer
string reloadStartSound
string reloadStartSoundPlayer
string reloadEndSound
string reloadEndSoundPlayer
string altSwitchSound
string raiseSound
string putawaySound
string noteTrackSoundA
string noteTrackSoundB
string noteTrackSoundC
string noteTrackSoundD

string hudIcon
string modeIcon
string killIcon

keyenum("rumble.gdf") fireRumble
keyenum("rumble.gdf") meleeImpactRumble

vcontainer
{
	scrollbox(targetFolder)
	[
		exec
		{
			label("Target Folder")
			tooltip("Select platform-gametype this weapon will be used in.")
			width(270)
		}
	]
	
	edit(displayName)
	[
		exec
		{
			label("Display Name")
			tooltip("Localization alias for weapon name displayed on HUD in game.")
			width(500)
		}
	]
	
	edit(modeName)
	[
		exec
		{
			label("Mode Name")
			tooltip("Localization alias for selective fire mode text displayed on HUD in game.")
			width(500)
		}
	]

   	scrollbox(playerAnimType)
	[
		exec
		{
			label("Player Anim Type")
			tooltip("Select an Player Anim Type - specifies \"playerAnimType\" in playeranim.script")
			visible(targetFolder == "2: Multi-Player")
		}
	]
	
	edit(altWeapon)
	[
		exec
		{
			label("Alt Weapon Name")
			tooltip("Weapon to switch to when this weapon's selective fire mode is switched in the game.")
			width(500)
		}
	]
	

	edit(AIOverlayDescription)
	[
		exec
		{
			label("AI Description")
			tooltip("Localization alias for text shown when crosshair is placed over a friendly. Eg. Rifleman, Submachine Gunner, etc.")
			width(500)
		}
	]
    
   	scrollbox(weaponType)
	[
		exec
		{
			label("Type")
			tooltip("Select a weapon type.")
		}
	]
	
   	scrollbox(weaponClass)
	[
		exec
		{
			label("Class")
			tooltip("Select an appropriate class for this weapon.")
		}
	]
	
   	scrollbox(weaponSlot)
	[
		exec
		{
			label("Slot")
			tooltip("CoD1's Primary, Secondary (Pistol), grenades slots. Only Primary is used in CoD2.")
		}
	]
	
	hcontainer
	{
	//	checkbox(twoHanded)
	//	[
	//		exec
	//		{
	//			label("Two Handed")
	//			tooltip("Not used in CoD2.")
	//			righttext()
	//		}
	//	]
		
		checkbox(rifleBullet)
		[
			exec
			{
				label("Rifle Bullet")
				tooltip("Uses pistol bullets if not checked. Rifle bullets apply damage to the highest priority hit location (locationdamage.gdt) along the bullet's path, and will go through people. Pistol bullets don't.")
				righttext()
			}
		]
		
		checkbox(armorPiercing)
		[
			exec
			{
				label("Armor Piercing")
				tooltip("Does damage to armored targets if checked.")
				righttext()
			}
		]
	}
	
	hcontainer
	{
		checkbox(semiAuto)
		[
			exec
			{
				label("Semi Auto")
				tooltip("Turn this on for any weapon that requires the trigger to be pulled for each bullet fired, including bolt-action weapons.")
				righttext()
			}
		]
		
		checkbox(boltAction)
		[
			exec
			{
				label("Bolt Action")
				tooltip("Turn this on for bolt-action weapons only. Animation control.")
				righttext()
			}
		]
	}
	
	hcontainer
	{
		checkbox(aimDownSight)
		[
			exec
			{
				label("ADS")
				tooltip("Must be turned on for proper viewmodel appearance of a weapon that can be Aimed Down the Sight (ADS).")
				righttext()
			}
		]
		
		checkbox(rechamberWhileAds)
		[
			exec
			{
				label("ADS Rechamber")
				tooltip("Turn this on if you want the player to be able to rechamber a bolt-action weapon while still in ADS.")
				righttext()
			}
		]
	}
	
	hcontainer
	{
		checkbox(noPartialReload)
		[
			exec
			{
				label("No Partial Reload")
				tooltip("When noPartialReload is set for a weapon, it can not be reloaded unless reloadAmmoAdd amount of ammo can be put into the gun. If reloadAmmoAdd is 0, it's treated as the weapon's clip size.")
				righttext()
			}
		]
		
		checkbox(segmentedReload)
		[
			exec
			{
				label("Segmented Reload")
				tooltip("Turn on for weapons that reload X rounds at a time (Lee-Enfield, bolt-action sniper rifles), set reload amounts in Reload Ammo Add and Reload Start Add.")
				righttext()
			}
		]
	}
	
	hcontainer
	{
		checkbox(wideListIcon)
		[
			exec
			{
				label("Wide List Icon")
				tooltip("Used for weapons that use wide HUD icons when drawing cursor hints and MP weapon selection. (Rifle vs. Grenade)")
				righttext()
			}
		]
		
		checkbox(wideKillIcon)
		[
			exec
			{
				label("Wide Kill Icon")
				tooltip("Used for weapons that have a wide kill icon in MP. (Rifle vs Grenade).")
				righttext()
			}
		]
	}
	
	hcontainer
	{
		checkbox(flipKillIcon)
		[
			exec
			{
				label("Flip Kill Icon")
				tooltip("Used for weapons that need to have their kill icon horizontally flipped before displaying. (For MP obituaries).")
				righttext()
			}
		]
	}

	floatedit(enemyCrosshairRange, 1, 100)
	[
		exec
		{
			label("Enemy Crosshair Range")
			tooltip("The range in world units at which an enemy will change your crosshair color. (1 world unit = 1 inch)")
			width(280)
			labelwidth(180)
		}
	]
		
	floatedit(moveSpeedScale, 0.1, 1)
	[
		exec
		{
			label("Move Speed Scale")
			tooltip("When using this weapon, player movement speed is multiplied by this amount.")
		}
	]
	
	hcontainer
	{
		spinedit(gunMaxPitch, 1, 10)
		[
			exec
			{
				label("Max Gun Pitch")
				tooltip("Maximum allowed vertical ascent of the viewmodel due to recoil (degrees).")
			}
		]
		
		spinedit(gunMaxYaw, 1, 10)
		[
			exec
			{
				label("Max Gun Yaw")
				tooltip("Maximum allowed horizontal travel of the viewmodel due to recoil (degrees).")
			}
		]
	}
	
	
	////////////////////////////////////////
	// Aim Assist
	////////////////////////////////////////
	vcontainer
	{
		floatedit(autoAimRange, 1, 100)
		[
			exec
			{
				label("Auto Aim Range")
				tooltip("(Console only.) The range in world units up to which entering ADS will lock-on to enemies. (1 world unit = 1 inch)")
			}
		]
		
		hcontainer
		{
			floatedit(slowdownAimRange, 1, 100)
			[
				exec
				{
					label("Slowdown Range")
					tooltip("(Console only.) The range in world units which the crosshair will slowdown over a target. (1 world unit = 1 inch)")
				}
			]
			
			floatedit(slowdownAimRangeAds, 1, 100)
			[
				exec
				{
					label("Slowdown Range ADS")
					tooltip("(Console only.) The range in world units which the crosshair will slowdown over a target in ADS. (1 world unit = 1 inch)")
					width(260)
					labelwidth(160)
				}
			]
		}
		
		hcontainer
		{
			floatedit(lockonAimRange, 1, 100)
			[
				exec
				{
					label("Lock-On Range")
					tooltip("(Console only.) The range in world units up to which the view will lock onto a target. (1 world unit = 1 inch)")
				}
			]
			
			floatedit(lockonAimRangeAds, 1, 100)
			[
				exec
				{
					label("Lock-On Range ADS")
					tooltip("(Console only.) The range in world units up to which the view will lock onto a target in ADS. (1 world unit = 1 inch)")
					width(260)
					labelwidth(160)
				}
			]
		}
	}
	[
		exec
		{
			groupBox("Aim Assist (Console only)")
		}
	]
	
	
	////////////////////////////////////////
	// Ammunition
	////////////////////////////////////////
	vcontainer
	{
		edit(ammoName)
		[
			exec
			{
				label("Ammo Name")
				tooltip("Allows different weapons to share the same ammo pool.")
				width(500)
			}
		]
		
		edit(clipName)
		[
			exec
			{
				label("Clip Name")
				tooltip("Allows different weapons to share clips. Used for weapons that have a selective fire option, and would therefore need to use the same type of clip.")
				width(500)
			}
		]
		
		hcontainer
		{
			spinedit(maxAmmo, 10, 20)
			[
				exec
				{
					label("Max Ammo")
					tooltip("Max ammo the player can collect for this weapon. No effect on AI.")
				}
			]
		
			spinedit(startAmmo, 1, 10)
			[
				exec
				{
					label("Start Ammo")
					tooltip("How much ammo the player gets when starting with this weapon. One clip/magazine from this amount will be already in the weapon. No effect on AI.")
				}
			]

			spinedit(clipSize, 1, 10)
			[
				exec
				{
					label("Clip Size")
					tooltip("Specifies how many bullets per clip/magazine.")
				}
			]
		}
		
		hcontainer
		{
			spinedit(dropAmmoMin, 1, 10)
			[
				exec
				{
					label("Drop Min")
					tooltip("When dropped by AI/player/hand-placed in editor, contains at least this much ammo. Not limited to real-life clip/magazine size.")
				}
			]
			
			spinedit(dropAmmoMax, 1, 10)
			[
				exec
				{
					label("Drop Max")
					tooltip("When dropped by AI/player/hand-placed in editor, contains no more than this much ammo. Not limited to real-life clip/magazine size.")
				}
			]			
				
			spinedit(shotCount, 1, 5)
			[
				exec
				{
					label("Shotgun Shot Count")
					tooltip("Specifies how many chunks per shotgun blast.")
				}
			]
		}
		
		hcontainer
		{
			spinedit(reloadAmmoAdd, 1, 10)		
			[
				exec
				{
					label("Reload Ammo Add")
					tooltip("For weapons with Segmented Reload turned on. Amount to add when reloading with some amount of bullets still remaining in the weapon.")
				}
			]
			
			spinedit(reloadStartAdd, 1, 10)
			[
				exec
				{
					label("Reload Start Add")
					tooltip("For weapons with Segmented Reload turned on. Amount to add for the first reload segment (ie: when weapon is empty.)")
				}
			]		
		}
	}
	[
		exec
		{
			groupBox("Ammunition")
		}
	]
		
	////////////////////////////////////////
	// Damage
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			spinedit(minDamage, 1, 10)
			[
				exec
				{
					label("Min Dmg")
					tooltip("Damage per-bullet, applied beyond Min Dmg Range.")
				}
			]
			
			floatedit(minDamageRange, 120, 8000)
			[
				exec
				{
					label("Min Dmg Range")
					tooltip("Range in world units, beyond which the minimum damage is applied. (1 world unit = 1 inch)")
				}
			]
		}
		
		hcontainer
		{
			spinedit(damage, 1, 10)
			[
				exec
				{
					label("Max Dmg")
					tooltip("Damage per-bullet, applied up to Max Dmg Range. Damage falls off linearly from Max Dmg Range until reaching Min Dmg at Min Dmg Range.")
				}
			]
			
			floatedit(maxDamageRange, 120, 8000)
			[
				exec
				{
					label("Max Dmg Range")
					tooltip("Range in world units, up to which the maximum damage is applied. (1 world unit = 1 inch)")	
				}
			]
		}

		spinedit(meleeDamage, 1, 10)
		[
			exec
			{
				label("Melee")
				tooltip("Damage per melee hit.")
			}
		]
	}
	[
		exec
		{
			groupBox("Damage")
		}
	]
	
	////////////////////////////////////////
	// Location Damage
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(locNone, 0.1, 0.2)
			[
				exec
				{
					label("None")
					tooltip("Unrelated to weapon. Used for damage that's not location based, such as grenades or falling.  Included here for completeness.")
				}
			]

			floatedit(locHelmet, 0.1, 0.2)
			[
				exec
				{
					label("Helmet")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
			
		hcontainer
		{
			floatedit(locHead, 0.1, 0.2)
			[
				exec
				{
					label("Head")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locNeck, 0.1, 0.2)
			[
				exec
				{
					label("Neck")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(locTorsoUpper, 0.1, 0.2)
			[
				exec
				{
					label("Upper Torso")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locTorsoLower, 0.1, 0.2)
			[
				exec
				{
					label("Lower Torso")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
	
		hcontainer
		{
			floatedit(locLeftArmUpper, 0.1, 0.2)
			[
				exec
				{
					label("Left Upper Arm")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locRightArmUpper, 0.1, 0.2)
			[
				exec
				{
					label("Right Upper Arm")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(locLeftArmLower, 0.1, 0.2)
			[
				exec
				{
					label("Left Lower Arm")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locRightArmLower, 0.1, 0.2)
			[
				exec
				{
					label("Right Lower Arm")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(locLeftHand, 0.1, 0.2)
			[
				exec
				{
					label("Left Hand")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locRightHand, 0.1, 0.2)
			[
				exec
				{
					label("Right Hand")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(locLeftLegUpper, 0.1, 0.2)
			[
				exec
				{
					label("Left Upper Leg")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locRightLegUpper, 0.1, 0.2)
			[
				exec
				{
					label("Right Upper Leg")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(locLeftLegLower, 0.1, 0.2)
			[
				exec
				{
					label("Left Lower Leg")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locRightLegLower, 0.1, 0.2)
			[
				exec
				{
					label("Right Lower Leg")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(locLeftFoot, 0.1, 0.2)
			[
				exec
				{
					label("Left Foot")
					tooltip("Damage per-bullet multiplier.")
				}
			]

			floatedit(locRightFoot, 0.1, 0.2)
			[
				exec
				{
					label("Right Foot")
					tooltip("Damage per-bullet multiplier.")
				}
			]
		}
		
		floatedit(locGun, 0.1, 0.2)
		[
			exec
			{
				label("Gun")
				tooltip("Damage per-bullet multiplier.")
			}
		]
	}
	[
		exec
		{
			groupBox("Location Damage")
		}
	]
	
	////////////////////////////////////////
	// State Timers
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(fireTime, 0.05, 0.2)
			[
				exec
				{
					label("Fire")
					tooltip("Rate of fire in seconds per round. Maximum possible rate is 0.05 seconds per round, or 1200 rounds per minute.")
				}
			]
			
			floatedit(fireDelay, 0.05, 0.2)
			[
				exec
				{
					label("Fire Delay")
					tooltip("Delay in seconds between pressing the fire button and the weapon actually firing.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(meleeTime, 0.05, 0.2)
			[
				exec
				{
					label("Melee")
					tooltip("Rate of fire in seconds per melee attack.")
				}
			]
			
			floatedit(meleeDelay, 0.05, 0.2)
			[
				exec
				{
					label("Melee Delay")
					tooltip("Delay in seconds between pressing the fire button and the melee attack actually happening.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(reloadTime, 0.05, 0.2)
			[
				exec
				{
					label("Reload")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(reloadEmptyTime, 0.05, 0.2)
			[
				exec
				{
					label("Reload Empty")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(reloadStartTime, 0.05, 0.2)
			[
				exec
				{
					label("Reload Start")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(reloadEndTime, 0.05, 0.2)
			[
				exec
				{
					label("Reload End")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
		}	
		
		hcontainer
		{
			floatedit(reloadAddTime, 0.05, 0.2)
			[
				exec
				{
					label("Reload Add")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(reloadStartAddTime, 0.05, 0.2)
			[
				exec
				{
					label("Reload Start Add")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]	
		}
		
		hcontainer
		{
			floatedit(rechamberTime, 0.05, 0.2)
			[
				exec
				{
					label("Rechamber")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(rechamberBoltTime, 0.05, 0.2)
			[
				exec
				{
					label("Rechamber Bolt")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
		}	
		
		hcontainer
		{
			floatedit(dropTime, 0.05, 0.2)
			[
				exec
				{
					label("Drop")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(raiseTime, 0.05, 0.2)
			[
				exec
				{
					label("Raise")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(altDropTime, 0.05, 0.2)
			[
				exec
				{
					label("Alt Drop")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(altRaiseTime, 0.05, 0.2)
			[
				exec
				{
					label("Alt Raise")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(quickDropTime, 0.05, 0.2)
			[
				exec
				{
					label("Quick Drop")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
			
			floatedit(quickRaiseTime, 0.05, 0.2)
			[
				exec
				{
					label("Quick Raise")
					tooltip("How long this weapon state will last. The viewmodel animations will get scaled to match the times set.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("State Timers")
		}
	]
	
	////////////////////////////////////////
	// Stand Movement Settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(standMoveF, 0.1, 1)
			[
				exec
				{
					label("Move Forward")
					tooltip("Viewmodel will translate forward/backward by this amount if the player is moving in this stance. (+/- for forward/backward respectively)")
				}
			]

			floatedit(standMoveR, 0.1, 1)
			[
				exec
				{
					label("Move Right")
					tooltip("Viewmodel will translate horizontally by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		
			floatedit(standMoveU, 0.1, 1)
			[
				exec
				{
					label("Move Up")
					tooltip("Viewmodel will translate vertically by this amount if the player is moving in this stance. (+/- for up/down respectively)")
				}
			]		
		}
		
		hcontainer
		{
			floatedit(standRotP, 0.1, 1)
			[
				exec
				{
					label("Rot Pitch")
					tooltip("Viewmodel will pitch by this amount if the player is moving in this stance. (+/- for down/up respectively)")
				}
			]
		
			floatedit(standRotY, 0.1, 1)
			[
				exec
				{
					label("Rot Yaw")
					tooltip("Viewmodel will yaw by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		
			floatedit(standRotR, 0.1, 1)
			[
				exec
				{
					label("Rot Roll")
					tooltip("Viewmodel will roll by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		}
		
		hcontainer
		{
			floatedit(standMoveMinSpeed, 1, 10)
			[
				exec
				{
					label("Move Min Speed")
					tooltip("Not used.")
				}
			]
		
			floatedit(posMoveRate, 0.1, 1)
			[
				exec
				{
					label("Pos Move Rate")
					tooltip("Controls speed of viewmodel translation while moving in stand and crouch, transitions between stand and crouch, and crouch into prone.")
				}
			]
		}
	
		hcontainer
		{
			floatedit(standRotMinSpeed, 1, 10)
			[
				exec
				{
					label("Rot Min Speed")
					tooltip("Not used.")
				}
			]
		
			floatedit(posRotRate, 0.1, 1)
			[
				exec
				{
					label("Pos Rot Rate")
					tooltip("Rotational speed of viewmodel in standing and crouching. If this is set in the prone section, a value should be entered here so that the viewmodel is able to rotate back to normal in crouch and stand.")
				}
			]		
		}
	}
	[
		exec
		{
			groupBox("Stand Movement Settings")
		}
	]
	
	////////////////////////////////////////
	// Crouch Movement Settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(duckedMoveF, 0.1, 1)
			[
				exec
				{
					label("Move Forward")
					tooltip("Viewmodel will translate forward/backward by this amount if the player is moving in this stance. (+/- for forward/backward respectively)")
				}
			]

			floatedit(duckedMoveR, 0.1, 1)
			[
				exec
				{
					label("Move Right")
					tooltip("Viewmodel will translate horizontally by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		
			floatedit(duckedMoveU, 0.1, 1)
			[
				exec
				{
					label("Move Up")
					tooltip("Viewmodel will translate vertically by this amount if the player is moving in this stance. (+/- for up/down respectively)")
				}
			]
		}
		
		hcontainer
		{
			floatedit(duckedRotP, 0.1, 1)
			[
				exec
				{
					label("Rot Pitch")
					tooltip("Viewmodel will pitch by this amount if the player is moving in this stance. (+/- for down/up respectively)")
				}
			]
		
			floatedit(duckedRotY, 0.1, 1)
			[
				exec
				{
					label("Rot Yaw")
					tooltip("Viewmodel will yaw by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		
			floatedit(duckedRotR, 0.1, 1)
			[
				exec
				{
					label("Rot Roll")
					tooltip("Viewmodel will roll by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		}
		
		hcontainer
		{
			floatedit(duckedOfsF, 0.1, 1)
			[
				exec
				{
					label("Offset Forward")
					tooltip("When the player changes to this stance, the viewmodel will slide forward by this amount. (-ive for backward)")
				}
			]
			
			floatedit(duckedOfsR, 0.1, 1)
			[
				exec
				{
					label("Offset Right")
					tooltip("When the player changes to this stance, the viewmodel will translate horizontally by this amount. (+/- for left/right respectively)")
				}
			]
			
			floatedit(duckedOfsU, 0.1, 1)
			[
				exec
				{
					label("Offset Up")
					tooltip("When the player changes to this stance, the viewmodel will translate vertically by this amount. (+/- for up/down respectively)")
				}
			]
		}
		
		floatedit(duckedMoveMinSpeed, 1, 10)
		[
			exec
			{
				label("Move Min Speed")
				tooltip("Not used.")
			}
		]
		
		floatedit(duckedRotMinSpeed, 1, 10)
		[
			exec
			{
				label("Rot Min Speed")
				tooltip("Not used.")
			}
		]
	}
	[
		exec
		{
			groupBox("Crouch Movement Settings")
		}
	]
	
	////////////////////////////////////////
	// Prone Movement Settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(proneMoveF, 0.1, 1)
			[
				exec
				{
					label("Move Forward")
					tooltip("Viewmodel will translate forward/backward by this amount if the player is moving in this stance. (+/- for forward/backward respectively)")
				}
			]

			floatedit(proneMoveR, 0.1, 1)
			[
				exec
				{
					label("Move Right")
					tooltip("Viewmodel will translate horizontally by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		
			floatedit(proneMoveU, 0.1, 1)
			[
				exec
				{
					label("Move Up")
					tooltip("Viewmodel will translate vertically by this amount if the player is moving in this stance. (+/- for up/down respectively)")
				}
			]
		}
		
		hcontainer
		{
			floatedit(proneRotP, 0.1, 1)
			[
				exec
				{
					label("Rot Pitch")
					tooltip("Viewmodel will pitch by this amount if the player is moving in this stance. (+/- for down/up respectively)")
				}
			]
			
			floatedit(proneRotY, 0.1, 1)
			[
				exec
				{
					label("Rot Yaw")
					tooltip("Viewmodel will yaw by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		
			floatedit(proneRotR, 0.1, 1)
			[
				exec
				{
					label("Rot Roll")
					tooltip("Viewmodel will roll by this amount if the player is moving in this stance. (+/- for left/right respectively)")
				}
			]
		}
		
		hcontainer
		{
			floatedit(proneOfsF, 0.1, 1)
			[
				exec
				{
					label("Offset Forward")
					tooltip("When the player changes to this stance, the viewmodel will slide forward by this amount. (-ive for backward)")
				}
			]
			
			floatedit(proneOfsR, 0.1, 1)
			[
				exec
				{
					label("Offset Right")
					tooltip("When the player changes to this stance, the viewmodel will translate horizontally by this amount. (+/- for left/right respectively)")
				}
			]
			
			floatedit(proneOfsU, 0.1, 1)
			[
				exec
				{
					label("Offset Up")
					tooltip("When the player changes to this stance, the viewmodel will translate vertically by this amount. (+/- for up/down respectively)")
				}
			]
		}
		
		hcontainer
		{
			floatedit(proneMoveMinSpeed, 1, 10)
			[
				exec
				{
					label("Move Min Speed")
					tooltip("Not used.")
				}
			]
		
			floatedit(posProneMoveRate, 0.1, 1)
			[
				exec
				{
					label("Pos Move Rate")
					tooltip("Controls the speed of viewmodel translation while moving in this stance and changing to crouched.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(proneRotMinSpeed, 1, 10)
			[
				exec
				{
					label("Rot Min Speed")
					tooltip("Not used.")
				}
			]
		
			floatedit(posProneRotRate, 0.1, 1)
			[
				exec
				{
					label("Pos Rot Rate")
					tooltip("Controls the speed of viewmodel rotation while moving in this stance.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("Prone Movement Settings")
		}
	]
	
	////////////////////////////////////////
	// Idle Settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			spinedit(hipIdleAmount, 1, 10)
			[
				exec
				{
					label("Hip Amount")
					tooltip("Strength of viewmodel wavering motion when in hipfire position.")
				}
			]
				
			spinedit(adsIdleAmount, 1, 10)
			[
				exec
				{
					label("ADS Amount")
					tooltip("Strength of range of viewmodel (or sniper rifle overlay) wavering motion when in ADS.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipIdleSpeed, 0.1, 1.0)
			[
				exec
				{
					label("Hip Speed")
					tooltip("How fast the viewmodel wavers in hipfire position within Hip Amount.")
				}
			]
				
			floatedit(adsIdleSpeed, 0.1, 1.0)
			[
				exec
				{
					label("ADS Speed")
					tooltip("How fast the viewmodel wavers in ADS within ADS Amount.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(idleCrouchFactor, 0.01, 0.1)
			[
				exec
				{
					label("Crouch Factor")
					tooltip("Hip/ADS Amount multiplier for reducing viewmodel wavering when in this stance.")
				}
			]
			
			floatedit(idleProneFactor, 0.01, 0.1)
			[
				exec
				{
					label("Prone Factor")
					tooltip("Hip/ADS Amount multiplier for reducing viewmodel wavering when in this stance.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("Idle Settings")
		}
	]
	
	////////////////////////////////////////
	// ADS Settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(adsSpread, 0.1, 1)
			[
				exec
				{
					label("Spread")
					tooltip("Size of bullet spread cone when firing in ADS mode. Bullets will project randomly within the confines of the cone.")
				}
			]
			
			floatedit(adsAimPitch, 0.1, 1)
			[
				exec
				{
					label("Aim Pitch")
					tooltip("Adjusts the pitch of the viewmodel in ADS. Defaults to 0, -6 is perfectly centered.")
				}
			]
		}
				
		hcontainer
		{
			floatedit(adsTransInTime, 0.05, 0.1)
			[
				exec
				{
					label("Trans In Time")
					tooltip("Time it will take to switch from hipfire to ADS.")
				}
			]
			
			floatedit(adsTransOutTime, 0.05, 0.1)
			[
				exec
				{
					label("Trans Out Time")
					tooltip("Time it will take to switch from ADS to hipfire.")
				}
			]
		}
		
		hcontainer
		{
		//	floatedit(adsTransBlendTime, 0.01, 0.1)
		//	[
		//	exec
		//	{
		//		label("Trans Blend Time")
		//		tooltip("Not used in CoD2.")
		//	}
		//	]
			
			floatedit(adsReloadTransTime, 0.01, 0.1)
			[
				exec
				{
					label("Reload Trans Time")
					tooltip("Time it takes once you start the reload to re-enter ADS. (ie: It allows you to finish up reloading while you enter ADS.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(adsCrosshairInFrac, 0.05, 0.1)
			[
				exec
				{
					label("Crosshair In Frac")
					tooltip("Fraction of the hipfire-to-ADS transition time over which the crosshair disappears.")
				}
			]
			
			floatedit(adsCrosshairOutFrac, 0.05, 0.1)
			[
				exec
				{
					label("Crosshair Out Frac")
					tooltip("Fraction of the ADS-to-hipfire transition time over which the crosshair appears.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(adsZoomFov, 1, 5)
			[
				exec
				{
					label("Zoom FOV")
					tooltip("Field of view when in ADS.")
				}
			]
			
			floatedit(adsZoomInFrac, 0.05, 0.1)
			[
				exec
				{
					label("Zoom In Frac")
					tooltip("Fraction of the hipfire-to-ADS transition time over which the FOV zoom-in effect happens.")
				}
			]
			
			floatedit(adsZoomOutFrac, 0.05, 0.1)
			[
				exec
				{
					label("Zoom Out Frac")
					tooltip("Fraction of the ADS-to-hipfire transition time over which the FOV zoom-out effect happens.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(adsBobFactor, 0.05, 0.1)
			[
				exec
				{
					label("Bob Factor")
					tooltip("Strength of viewmodel bobbing due to player movement when using this weapon.")
				}
			]
			
			floatedit(adsViewBobMult, 0.1, 1)
			[
				exec
				{
					label("View Bob Mult")
					tooltip("Bob Factor multiplier for view bobbing due to player movement when using this weapon in ADS.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(adsViewErrorMin, 0.1, 1)
			[
				exec
				{
					label("Min View Error")
					tooltip("Min View Error.")
				}
			]
			
			floatedit(adsViewErrorMax, 0.1, 1)
			[
				exec
				{
					label("Max View Error")
					tooltip("Max View Error.")
				}
			]	
		}
	}
	[
		exec
		{
			groupBox("ADS Settings")
		}
	]
	
	////////////////////////////////////////
	// Hip Spread
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(hipSpreadStandMin, 0.1, 1)
			[
				exec
				{
					label("Stand Min")
					tooltip("Smallest diameter the crosshairs can contract to.")
				}
			]

			floatedit(hipSpreadMax, 0.1, 1)
			[
				exec
				{
					label("Stand Max")
					tooltip("Largest diameter the crosshairs can expand to while standing.") 
				}
			]

			floatedit(hipSpreadDecayRate, 0.05, 0.1)
			[
				exec
				{
					label("Decay Rate")
					tooltip("Rate at which the crosshairs try to return to the Min hip spread size.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipSpreadDuckedMin, 0.1, 1)
			[
				exec
				{
					label("Crouch Min")
					tooltip("Size of the crosshairs at rest when crouched.")
				}
			]

			floatedit(hipSpreadDuckedMax, 0.1, 1)
			[
				exec
				{
					label("Crouch Max")
					tooltip("Largest diameter the crosshairs can expand to while crouched.") 
				}
			]

			floatedit(hipSpreadDuckedDecay, 0.1, 1)
			[
				exec
				{
					label("Crouch Decay")
					tooltip("Multiplier of Decay Rate for crouched stance, controlling how fast the crosshairs return to Crouch Min.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipSpreadProneMin, 0.1, 1)
			[
				exec
				{
					label("Prone Min")
					tooltip("Size of the crosshairs at rest when prone.")
				}
			]

			floatedit(hipSpreadProneMax, 0.1, 1)
			[
				exec
				{
					label("Prone Max")
					tooltip("Largest diameter the crosshairs can expand to while prone.") 
				}
			]
			
			floatedit(hipSpreadProneDecay, 0.1, 1)
			[
				exec
				{
					label("Prone Decay")
					tooltip("Multiplier of Decay Rate for prone stance, controlling how fast the crosshairs return to Prone Min.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipSpreadFireAdd, 0.01, 0.1)
			[
				exec
				{
					label("Fire Add")
					tooltip("Amount by which the crosshairs expand per bullet fired.")
				}
			]

			floatedit(hipSpreadMoveAdd, 0.1, 1)
			[
				exec
				{
					label("Move Add")
					tooltip("Rate of crosshair expansion due to player movement.")
				}
			]

			floatedit(hipSpreadTurnAdd, 0.1, 1)
			[
				exec
				{
					label("Turn Add")
					tooltip("Rate of crosshair expansion due to player panning the view in any direction.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("Hip Spread Settings")
		}
	]
	
	////////////////////////////////////////
	// Gun Kick
	////////////////////////////////////////
	vcontainer
	{
	    hcontainer
		{
			spinedit(hipGunKickReducedKickBullets, 1, 5)
			[
				exec
				{
					label("Hip Red. Kick Bullets")
					tooltip("Hipfire viewmodel control reduced kick number of bullets. This is the number of bullets before the weapon uses a full kick amount.")
				}
			]
			
			spinedit(adsGunKickReducedKickBullets, 1, 5)
			[
				exec
				{
					label("ADS Red. Kick Bullets")
					tooltip("ADS viewmodel control reduced kick number of bullets. This is the number of bullets before the weapon uses a full kick amount.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickReducedKickPercent, 1, 5)
			[
				exec
				{
					label("Hip Red. Kick Percent")
					tooltip("Hip viewmodel control reduced kick percentage. This is the percentage of the full kick amount to kick the gun for the first few bullets.")
				}
			]
			
			floatedit(adsGunKickReducedKickPercent, 1, 5)
			[
				exec
				{
					label("ADS Red. Kick Percent")
					tooltip("ADS viewmodel control reduced kick percentage. This is the percentage of the full kick amount to kick the gun for the first few bullets.")
				}
			]
		}
		
		
		hcontainer
		{
			floatedit(hipGunKickPitchMin, 1, 5)
			[
				exec
				{
					label("Hip Pitch Min")
					tooltip("Hipfire viewmodel control. +/- sign means 'kick down/up'. Larger absolute numbers increase viewmodel climb/descent. From -100 to 100. Actual viewmodel angle will not exceed Max Gun Pitch.")
				}
			]
			
			floatedit(adsGunKickPitchMin, 1, 5)
			[
				exec
				{
					label("ADS Pitch Min")
					tooltip("ADS viewmodel control. +/- sign means 'kick down/up'. Larger absolute numbers increase viewmodel climb/descent. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickPitchMax, 1, 5)
			[
				exec
				{
					label("Hip Pitch Max")
					tooltip("Hipfire viewmodel control. +/- sign means 'kick down/up'. Larger absolute numbers increase viewmodel climb/descent. From -100 to 100. Actual viewmodel angle will not exceed Max Gun Pitch.")
				}
			]
			
			floatedit(adsGunKickPitchMax, 1, 5)
			[
				exec
				{
					label("ADS Pitch Max")
					tooltip("ADS viewmodel control. +/- sign means 'kick down/up'. Larger absolute numbers increase viewmodel climb/descent. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickYawMin, 1, 5)
			[
				exec
				{
					label("Hip Yaw Min")
					tooltip("Hipfire viewmodel control. +/- sign means 'kick left/right'. Larger absolute numbers increase viewmodel yawing. From -100 to 100. Actual viewmodel angle will not exceed Max Gun Yaw.")
				}
			]
			
			floatedit(adsGunKickYawMin, 1, 5)
			[
				exec
				{
					label("ADS Yaw Min")
					tooltip("ADS viewmodel control. +/- sign means 'kick left/right'. Larger absolute numbers increase viewmodel yawing. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickYawMax, 1, 5)
			[
				exec
				{
					label("Hip Yaw Max")
					tooltip("Hipfire viewmodel control. +/- sign means 'kick left/right'. Larger absolute numbers increase viewmodel yawing. From -100 to 100. Actual viewmodel angle will not exceed Max Gun Yaw.")
				}
			]
			
			floatedit(adsGunKickYawMax, 1, 5)
			[
				exec
				{
					label("ADS Yaw Max")
					tooltip("ADS viewmodel control. +/- sign means 'kick left/right'. Larger absolute numbers increase viewmodel yawing. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickAccel, 1, 10)
			[
				exec
				{
					label("Hip Accel")
					tooltip("Rate at which viewmodel attempts to recenter in hipfire. Directly opposes yaws and pitch accumulation.")
				}
			]

			floatedit(adsGunKickAccel, 1, 10)
			[
				exec
				{
					label("ADS Accel")
					tooltip("Rate at which viewmodel attempts to recenter in ADS. Directly opposes yaws and pitch accumulation.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickSpeedMax, 1, 10)
			[
				exec
				{
					label("Hip Speed Max")
					tooltip("Maximum deflection speed reached by the viewmodel in hipfire.")
					
				}
			]
			
			floatedit(adsGunKickSpeedMax, 1, 10)
			[
				exec
				{
					label("ADS Speed Max")
					tooltip("Maximum deflection speed reached by the viewmodel in ADS.")
				}
			]
		}

		hcontainer
		{
			floatedit(hipGunKickSpeedDecay, 0.1, 1)
			[
				exec
				{
					label("Hip Speed Decay")
					tooltip("Strength of decay on viewmodel deflection speed in hipfire.")
				}
			]
			
			floatedit(adsGunKickSpeedDecay, 0.1, 1)
			[
				exec
				{
					label("ADS Speed Decay")
					tooltip("Strength of decay on viewmodel deflection speed in ADS.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipGunKickStaticDecay, 0.1, 1)
			[
				exec
				{
					label("Hip Static Decay")
					tooltip("Strength of decay on viewmodel recentering once it has stopped deflecting.")
				}
			]
			
			floatedit(adsGunKickStaticDecay, 0.1, 1)
			[
				exec
				{
					label("ADS Static Decay")
					tooltip("Strength of decay on viewmodel recentering once it has stopped deflecting.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("Gun Kick Settings")
		}
	]
	
	////////////////////////////////////////
	// View Kick
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(hipViewKickPitchMin, 1, 10)
			[
				exec
				{
					label("Hip Pitch Min")
					tooltip("Hipfire view kick control. -/+ sign means 'kick down/up'. Larger absolute numbers increase view kick climb/descent. From -100 to 100.")
				}
			]
			
			floatedit(adsViewKickPitchMin, 1, 10)
			[
				exec
				{
					label("ADS Pitch Min")
					tooltip("ADS view kick control. -/+ sign means 'kick down/up'. Larger absolute numbers increase view kick climb/descent. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipViewKickPitchMax, 1, 10)
			[
				exec
				{
					label("Hip Pitch Max")
					tooltip("Hipfire view kick control. -/+ sign means 'kick down/up'. Larger absolute numbers increase view kick climb/descent. From -100 to 100.")
				}
			]
			
			floatedit(adsViewKickPitchMax, 1, 10)
			[
				exec
				{
					label("ADS Pitch Max")
					tooltip("ADS view kick control. -/+ sign means 'kick down/up'. Larger absolute numbers increase view kick climb/descent. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipViewKickYawMin, 1, 10)
			[
				exec
				{
					label("Hip Yaw Min")
					tooltip("Hipfire view kick control. -/+ sign means 'kick right/left'. Larger absolute numbers increase view kick yaw. From -100 to 100.")
				}
			]
			
			floatedit(adsViewKickYawMin, 1, 10)
			[
				exec
				{
					label("ADS Yaw Min")
					tooltip("ADS view kick control. -/+ sign means 'kick right/left'. Larger absolute numbers increase view kick yaw. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipViewKickYawMax, 1, 10)
			[
				exec
				{
					label("Hip Yaw Max")
					tooltip("Hipfire view kick control. -/+ sign means 'kick right/left'. Larger absolute numbers increase view kick yaw. From -100 to 100.")
				}
			]
			
			floatedit(adsViewKickYawMax, 1, 10)
			[
				exec
				{
					label("ADS Yaw Max")
					tooltip("ADS view kick control. -/+ sign means 'kick right/left'. Larger absolute numbers increase view kick yaw. From -100 to 100.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipViewKickCenterSpeed, 10, 100)
			[
				exec
				{
					label("Hip Center Speed")
					tooltip("Speed with which the view continuously attempts to recenter in hipfire.")
				}
			]
			
			floatedit(adsViewKickCenterSpeed, 10, 100)
			[
				exec
				{
					label("ADS Center Speed")
					tooltip("Speed with which the view continuously attempts to recenter in ADS.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("View Kick Settings")
		}
	]	
	
	////////////////////////////////////////
	// Sway settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{
			floatedit(swayMaxAngle, 0.05, 0.1)
			[
				exec
				{
					label("Max Angle")
					tooltip("Max angle change that will be applied to the hipfire viewmodel sway.")
				}
			]		
			floatedit(adsSwayMaxAngle, 0.05, 0.1)
			[
				exec
				{
					label("ADS Max Angle")
					tooltip("Max angle change that will be applied to the ADS viewmodel sway.")
				}
			]		
		}
		
		hcontainer
		{
			floatedit(swayLerpSpeed, 0.05, 0.1)
			[
				exec
				{
					label("Lerp Speed")
					tooltip("Speed at which the sway will lerp in hipfire.")
				}
			]		
			floatedit(adsSwayLerpSpeed, 0.05, 0.1)
			[
				exec
				{
					label("ADS Lerp Speed")
					tooltip("Speed at which the sway will lerp in ADS.")
				}
			]		
		}
		
		hcontainer
		{
			floatedit(swayPitchScale, 0.05, 0.1)
			[
				exec
				{
					label("Pitch Scale")
					tooltip("Amount of pitch change in the viewmodel to apply to the sway pitch in hipfire.")
				}
			]		
			floatedit(adsSwayPitchScale, 0.05, 0.1)
			[
				exec
				{
					label("ADS Pitch Scale")
					tooltip("Amount of pitch change in the viewmodel to apply to the sway pitch in ADS.")
				}
			]		
		}
		
		hcontainer
		{
			floatedit(swayYawScale, 0.05, 0.1)
			[
				exec
				{
					label("Yaw Scale")
					tooltip("Amount of yaw change in the viewmodel to apply to the sway yaw in hipfire.")
				}
			]		
			floatedit(adsSwayYawScale, 0.05, 0.1)
			[
				exec
				{
					label("ADS Yaw Scale")
					tooltip("Amount of yaw change in the viewmodel to apply to the sway yaw in ADS.")
				}
			]		
		}
		
		hcontainer
		{
			floatedit(swayHorizScale, 0.05, 0.1)
			[
				exec
				{
					label("Horiz Scale")
					tooltip("Amount of yaw change in the viewmodel to apply to the sway horizontal offset in hipfire.")
				}
			]		
			floatedit(adsSwayHorizScale, 0.05, 0.1)
			[
				exec
				{
					label("ADS Horiz Scale")
					tooltip("Amount of yaw change in the viewmodel to apply to the sway horizontal offset in ADS.")
				}
			]		
		}
		
		hcontainer
		{
			floatedit(swayVertScale, 0.05, 0.1)
			[
				exec
				{
					label("Vert Scale")
					tooltip("Amount of pitch change in the view model to apply to the sway vertical offset in hipfire.")
				}
			]		
			floatedit(adsSwayVertScale, 0.05, 0.1)
			[
				exec
				{
					label("ADS Vert Scale")
					tooltip("Amount of pitch change in the view model to apply to the sway vertical offset in ADS.")
				}
			]		
		}
		
		floatedit(swayShellShockScale, 0.05, 0.1)
		[
			exec
			{
				label("Shell Shock Scale")
				tooltip("This scale gets applied to the weapon sway while you're in shell shock.")
			}
		]
	}
	[
		exec
		{
			groupBox("Sway Settings")
		}
	]
		
	////////////////////////////////////////
	// AI Settings
	////////////////////////////////////////
	vcontainer
	{
		hcontainer
		{  
			floatedit(fightDist, 1, 100)
			[
				exec
				{
					label("Fight Distance")
					tooltip("Aggro radius. AI using this weapon try to fight enemies detected in this radius. Center of this circle constantly traces along AI's path up to maxdist.")
				}
			]
			
			floatedit(maxDist, 1, 100)
			[
				exec
				{
					label("Max Distance")
					tooltip("Effective range radius. AI must get to this distance before opening fire on their target with this weapon.")
				}
			]
		}
	
		fileedit(aiVsAiAccuracyGraph)
		[
			exec
			{
				label("AI Vs. AI Accuracy")
				tooltip("Graph file for in-game editing of the non-linear accuracy curve used by the AI for this weapon against another AI.")
				reldir("share/raw/accuracy/aivsai/")
				width(500)
			}
		]

		fileedit(aiVsPlayerAccuracyGraph)
		[
			exec
			{
				label("AI Vs. Player Accuracy")
				tooltip("Graph file for in-game editing of the non-linear accuracy curve used by the AI for this weapon against the player.")
				reldir("share/raw/accuracy/aivsplayer/")
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("AI Settings")
		}
	]
	
	////////////////////////////////////////
	// Reticle Settings
	////////////////////////////////////////
	vcontainer
	{
		fileedit(reticleCenter)
		[
			exec
			{
				label("Center Reticle")
				tooltip("Center Reticle.")
				reldir("pc/main/")
				width(500)
			}
		]
		
		fileedit(reticleSide)
		[
			exec
			{
				label("Side Reticle")
				tooltip("Side Reticle.")
				reldir("pc/main/")
				width(500)
			}
		]
		
		hcontainer
		{
			spinedit(reticleCenterSize, 1, 2)
			[
				exec
				{
					label("Center Size")
					tooltip("Center Size.")
				}
			]
			
			spinedit(reticleSideSize, 1, 2)
			[
				exec
				{
					label("Side Size")
					tooltip("Side Size.")
				}
			]
		}
		
		hcontainer
		{
			floatedit(hipReticleSidePos, 0.1, 0.2)
			[
				exec
				{
					label("Side Position")
					tooltip("Side Position.")
				}
			]
			
			spinedit(reticleMinOfs, 1, 2)		
			[
				exec
				{
					label("Min Offset")
					tooltip("Min Offset.")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("Reticle Settings")
		}
	]
	
	////////////////////////////////////////
	// ADS Overlay Settings
	////////////////////////////////////////
	vcontainer
	{
		edit(adsOverlayShader)
		[
			exec
			{
				label("Shader")
				tooltip("Overlay for sniper rifles in ADS. Uses a quarter circle image to construct a full scope view.")
				width(500)
			}
		]
		
		scrollbox(adsOverlayReticle)
		[
			exec
			{
				label("Reticle")
				tooltip("Selects a preset image?")
			}
		]
		
		hcontainer
		{
			spinedit(adsOverlayWidth, 1, 10)
			[
				exec
				{
					label("Width")
				}
			]
			
			spinedit(adsOverlayHeight, 1, 10)
			[
				exec
				{
					label("Height")
				}
			]
		}
	}
	[
		exec
		{
			groupBox("ADS Overlay Settings")
		}
	]
		
	////////////////////////////////////////
	// XModels
	////////////////////////////////////////
	vcontainer
	{
		fileedit(gunModel)
		[
			exec
			{
				label("View Gun")
				reldir("pc/main/xmodel/")
				width(500)
			}
		]
		
		fileedit(handModel)
		[
			exec
			{
				label("Default view Hand")
				reldir("pc/main/xmodel/")
				width(500)
			}
		]
		
		fileedit(worldModel)
		[
			exec
			{
				label("World Gun")
				reldir("pc/main/")
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("XModels")
		}
	]
	
	////////////////////////////////////////
	// XAnims
	////////////////////////////////////////
	vcontainer
	{
		fileedit(idleAnim)
		[
			exec
			{
				label("Idle")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(emptyIdleAnim)
		[
			exec
			{
				label("Empty Idle")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(fireAnim)
		[
			exec
			{
				label("Fire")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(lastShotAnim)
		[
			exec
			{
				label("Last Shot")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(rechamberAnim)
		[
			exec
			{
				label("Rechamber")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(meleeAnim)
		[
			exec
			{
				label("Melee")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(reloadAnim)
		[
			exec
			{
				label("Reload")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(reloadEmptyAnim)
		[
			exec
			{
				label("Reload Empty")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(reloadStartAnim)
		[
			exec
			{
				label("Reload Start")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(reloadEndAnim)
		[
			exec
			{
				label("Reload End")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(raiseAnim)
		[
			exec
			{
				label("Raise")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(dropAnim)
		[
			exec
			{
				label("Drop")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(altRaiseAnim)
		[
			exec
			{
				label("Alt Raise")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(altDropAnim)
		[
			exec
			{
				label("Alt Drop")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(quickRaiseAnim)
		[
			exec
			{
				label("Quick Raise")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(quickDropAnim)
		[
			exec
			{
				label("Quick Drop")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(adsFireAnim)
		[
			exec
			{
				label("ADS Fire")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(adsLastShotAnim)
		[
			exec
			{
				label("ADS Last Shot")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(adsRechamberAnim)
		[
			exec
			{
				label("ADS Rechamber")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(adsUpAnim)
		[
			exec
			{
				label("ADS Up")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
		
		fileedit(adsDownAnim)
		[
			exec
			{
				label("ADS Down")
				reldir("pc/main/xanim/")
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("XAnims")
		}
	]

	////////////////////////////////////////
	// Particle Effects
	////////////////////////////////////////
	vcontainer
	{
		fileedit(viewFlashEffect)
		[
			exec
			{
				label("View Flash")
				reldir("pc/main/")
				width(500)
			}
		]
		
		fileedit(worldFlashEffect)
		[
			exec
			{
				label("World Flash")
				reldir("pc/main/")
				width(500)
			}
		]
		
		fileedit(shellEjectEffect)
		[
			exec
			{
				label("Shell Eject")
				reldir("pc/main/")
				width(500)
			}
		]
		fileedit(lastShotEjectEffect)
		[
			exec
			{
				label("Last Shot Eject")
				reldir("pc/main/")
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("Effects")
		}
	]
	
	////////////////////////////////////////
	// Sounds
	////////////////////////////////////////
	vcontainer
	{
		edit(pickupSound)
		[
			exec
			{
				label("Pickup")
				width(500)
			}
		]
			
		edit(ammoPickupSound)
		[
			exec
			{
				label("Ammo Pickup")
				width(500)
			}
		]
		
		edit(fireSound)
		[
			exec
			{
				label("Fire")
				width(500)
			}
		]
		
		edit(fireSoundPlayer)
		[
			exec
			{
				label("Fire (Player)")
				tooltip("Fire sound used by player. If not defined, player will play normal 'Fire' that is used by the AI.")
				width(500)
			}
		]
		
		edit(lastShotSound)
		[
			exec
			{
				label("Last Shot")
				width(500)
			}
		]
		
		edit(lastShotSoundPlayer)
		[
			exec
			{
				label("Last Shot (Player)")
				tooltip("Last Shot sound used by player. If not defined, player will play normal 'Last Shot' that is used by the AI.")
				width(500)
			}
		]
		
		edit(meleeSwipeSound)
		[
			exec
			{
				label("Melee Swipe")
				width(500)
			}
		]
		
		edit(rechamberSound)
		[
			exec
			{
				label("Rechamber")
				width(500)
			}
		]
		
		edit(rechamberSoundPlayer)
		[
			exec
			{
				label("Rechamber (Player)")
				tooltip("Rechamber sound used by player. If not defined, player will play normal 'Rechamber' that is used by the AI.")
				width(500)
			}
		]
		
		edit(reloadSound)
		[
			exec
			{
				label("Reload")
				width(500)
			}
		]
		
		edit(reloadSoundPlayer)
		[
			exec
			{
				label("Reload (Player)")
				tooltip("Reload sound used by player. If not defined, player will play normal 'Reload' that is used by the AI.")
				width(500)
			}
		]
		
		edit(reloadEmptySound)
		[
			exec
			{
				label("Reload Empty")
				width(500)
			}
		]
		
		edit(reloadEmptySoundPlayer)
		[
			exec
			{
				label("Reload Empty (Player)")
				tooltip("Reload Empty sound used by player. If not defined, player will play normal 'Reload Empty' that is used by the AI.")
				width(500)
			}
		]
		
		edit(reloadStartSound)
		[
			exec
			{
				label("Reload Start")
				width(500)
			}
		]
		
		edit(reloadStartSoundPlayer)
		[
			exec
			{
				label("Reload Start (Player)")
				tooltip("Reload Start sound used by player. If not defined, player will play normal 'Reload Start' that is used by the AI.")
				width(500)
			}
		]
		
		edit(reloadEndSound)
		[
			exec
			{
				label("Reload End")
				width(500)
			}
		]
		
		edit(reloadEndSoundPlayer)
		[
			exec
			{
				label("Reload End (Player)")
				tooltip("Reload End sound used by player. If not defined, player will play normal 'Reload End' that is used by the AI.")
				width(500)
			}
		]
		
		edit(altSwitchSound)
		[
			exec
			{
				label("Alt Switch")
				width(500)
			}
		]
		
		edit(raiseSound)
		[
			exec
			{
				label("Raise")
				width(500)
			}
		]
		
		edit(putawaySound)
		[
			exec
			{
				label("Put Away")
				width(500)
			}
		]
		
		edit(noteTrackSoundA)
		[
			exec
			{
				label("Note Track A")
				width(500)
			}
		]
		
		edit(noteTrackSoundB)
		[
			exec
			{
				label("Note Track B")
				width(500)
			}
		]
		
		edit(noteTrackSoundC)
		[
			exec
			{
				label("Note Track C")
				width(500)
			}
		]
		
		edit(noteTrackSoundD)
		[
			exec
			{
				label("Note Track D")
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("Sounds")
		}
	]
	
	////////////////////////////////////////
	// Rumbles
	////////////////////////////////////////
	vcontainer
	{
		scrollbox(fireRumble)
		[
			exec
			{
				width(500)
			}
		]

		scrollbox(meleeImpactRumble)
		[
			exec
			{
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("Rumbles")
		}
	]
		
	////////////////////////////////////////
	// Icons
	////////////////////////////////////////
	vcontainer
	{
		fileedit(hudIcon)
		[
			exec
			{
				label("Hud")
				reldir("pc/main/")
				width(500)
			}
		]
		
		fileedit(modeIcon)
		[
			exec
			{
				label("Mode")
				reldir("pc/main/")
				width(500)
			}
		]
		
		fileedit(killIcon)
		[
			exec
			{
				label("Kill")
				reldir("pc/main/")
				width(500)
			}
		]
	}
	[
		exec
		{
			groupBox("2D Icons")
		}
	]
}