SiN Episodes - FGD file

From Valve Developer Community
Jump to: navigation, search
SiN Episodes Level Creation


//====== Copyright © 1996-2005, Valve Corporation, All rights reserved. =======
//
// Purpose: Half-Life 2 game definition file (.fgd) 
//
//=============================================================================

@include "base.fgd"

//-------------------------------------------------------------------------
//
// NPC base classes
//
//-------------------------------------------------------------------------
@BaseClass base(BaseNPC) = BaseVehiclePassengerNPC
[
	vehicle(target_destination) : "Target Vehicle" : : "If set, the name of the vehicle which this NPC will use for vehicle inputs/outputs."
	vehiclepathcorner(target_destination) : "Target Vehicle Path Corner" : : "If set, the name of the path corner for this NPC to use when driving their target vehicle."
	drivermaxspeed(float) : "Driver Maxspeed" : 1 : "Percentage of vehicle's maxspeed.  Only used for driving."
	driverminspeed(float) : "Driver MinSpeed" : 0 : "Percentage of vehicle's maxspeed.  Only used for driving."

	input SetTargetVehicle(string) : "Change the target vehicle of this NPC."
	input EnterVehicle(integer) : "Tell this NPC to run and get in a role in their target vehicle."
	input EnterVehicleForce(integer) : "Force this NPC to get in a role in their target vehicle."
	input ExitVehicle(void) : "Tell this NPC to get out of their target vehicle."
	
	input DriverSetTargetPathCorner(string) : "Set the path corner the driver will use for pathing."
	input DriverSetMaxSpeed(float) : "Set the Maxspeed (percentage of vehicle's maxspeed) (only used if NPC is in driver role)."
	input DriverSetMinSpeed(float) : "Set the Minspeed (percentage of vehicle's maxspeed) (only used if NPC is in driver role)."
	input DriverStartDriving(void) : "Tell the driver to start driving (must be in driver role of vehicle)."
	input DriverStopDriving(void) : "Tell the driver to stop driving (must be in driver role of vehicle)."
	input DriverGotoPathCorner(string) : "Tell the driver to go to a specific path corner and continue from there (must be in driver role of vehicle)."
	input DriverStartBoost(void) : "Tell the driver to apply his boost (must be in driver role of vehicle)."
	input DriverStopBoost(void) : "Tell the driver to stop applying his boost (must be in driver role of vehicle)."
	input DriverLock(void) : "Disables the drivers ability to turn and brake."
	input DriverUnlock(void) : "Enables the drivers ability to turn and brake."
	
	output OnEnterVehicleAsDriver(void) : "Fires when this NPC enters a vehicle in the driver role"
	output OnEnterVehicleAsPassenger(void) : "Fires when this NPC enters a vehicle in the passenger role"
]

//-------------------------------------------------------------------------
@BaseClass base(BaseNPC) = TalkNPC
[
	UseSentence(string) : "Use Sentence"
	UnUseSentence(string) : "Un-Use Sentence"
]

@BaseClass base(BaseNPC ) = RappelNPC
[
	waitingtorappel(choices) : "Waiting to Rappel?" : "No" : "If yes, this NPC spawns suspended in air and awaits a BeginRappel input. It will then spawn a zipline and slide down. When it hits the ground, NPC will cut away the line and try to move forward a few feet to make room for the next NPC. The NPC will not attempt to clear its landing space if it cannot do so by taking a few steps forward" =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input BeginRappel(void) : "BeginRappel"
	input PauseRappel(void) : "PauseRappel"

//	 Outputs
	output OnRappelTouchdown(void) : "Fires when done rappeling"
]

@PointClass base(BasePropPhysics) studioprop() = prop_combine_ball :
	"A prop that physically simulates as a single rigid body. It can be constrained to other physics objects using hinges "+
	"or other constraints. It can also be configured to break when it takes enough damage."
[
//	 Inputs
	input Explode(void) : "Explode"
]

@SolidClass base(Trigger, Angles) = trigger_physics_trap :
	"A volumetric trigger that disintegrates enemies"
[
	dissolvetype(choices) : "Dissolve Type" : "Energy" =
	[
		0 : "Energy"
		1 : "Heavy electrical"
		2 : "Light electrical"
	]
]

@SolidClass base(Trigger) = trigger_weapon_dissolve :
	"A volumetric trigger that dissolves all weapons within it"
[
	emittername(target_destination) : "Emitter Name" : "" : "Name of a single or multiple entities to use as the basis for the emitted effects."

//	 Outputs
	output OnDissolveWeapon(void) : "Fires when one weapon is starting to dissolve in the trigger volume."
	output OnChargingPhyscannon(void) : "Fires when the trigger begins to charge the physcannon."

//	 Inputs
	input StopSound(void) : "Stops all sounds."
]

@SolidClass base(Trigger) = trigger_weapon_strip :
	"A volumetric trigger that strips combat characters of all weapons"
[
	KillWeapons(choices) : "Kill Weapons" : "No" =
	[
		0 : "No"
		1 : "Yes"
	]
]

@SolidClass base(Targetname, Origin, Angles, Global) = func_combine_ball_spawner :
	"A volumetric trigger that bestows super armor to the player"
[
	spawnflags(Flags) = 
	[
		4096 : "Start inactive" : 1
		8192 : "Combine power supply" : 0
	]

	ballcount(integer) : "Ball count" : 3 : "This is how many balls will be bouncing around inside the spawner"
	minspeed(float) : "Min ball speed" : "300.0" : "The minimum speed of balls that fly in the spawner"
	maxspeed(float) : "Max ball speed" : "600.0" : "The maximum speed of balls that fly in the spawner"
	ballradius(float) : "Ball radius" : "20.0" : "The radius of the energy balls"
	balltype(choices) : "Ball Type" : "Combine Energy Ball 1" =
	[
		0 : "Combine Energy Ball 1"
		1 : "Combine Energy Ball 2"
		2 : "Combine Energy Ball 3"
	]
	ballrespawntime(float) : "Ball Respawn Time" : "4.0f" : "The energy balls respawn time"

	input Enable(void) : "Enable spawning of combine balls"
	input Disable(void) : "Disable spawning of combine balls"

	output OnBallGrabbed(void) : "Fired when a combine ball is grabbed from the field by a mega physcannon"
	output OnBallReinserted(void) : "Fired when a combine ball is reinserted into the field (only gets triggered when Combine Power supply is checked)"
	output OnBallHitTopSide(void) : "Fired when a combine ball in hits the top side of the field (only gets triggered when Combine Power supply is checked)"
	output OnBallHitBottomSide(void) : "Fired when a combine ball in hits the bottom side of the field (only gets triggered when Combine Power supply is checked)"
	output OnLastBallGrabbed(void) : "Fired when the last combine ball is grabbed from the field by a mega physcannon"
	output OnFirstBallReinserted(void) : "Fired when the first combine ball is reinserted into the field (only gets triggered when Combine Power supply is checked)"
]

@NPCClass base(BaseNPC) sphere(innerradius) sphere(outerradius) studio("models/combine_camera/combine_camera.mdl") = npc_combine_camera :
	"Combine security camera"
[
	spawnflags(Flags) = 
	[
		32 : "Always Become Angry On New Enemy" : 1
		64 : "Ignore Enemies (Scripted Targets Only)" : 0
		128 : "Start Inactive" : 0
	]
	
	innerradius(integer) : "Inner radius" : 300 : "The camera will only lock onto enemies that are within the inner radius."
	outerradius(integer) : "Outer radius" : 450 : "The camera will flash amber when enemies are within the outer radius, but outside the inner radius."

	minhealthdmg(integer) : "Min req'd damage for hurting camera" : 0
	defaulttarget(target_destination) : "Default target" : "" : "The default target is the entity that the camera follows when it has no other target to track."

//	 Inputs
	input Disable(void) : "Disables the camera. If open, the camera closes."
	input Enable(void) : "Enables the camera. If closed, the camera opens."
	input Toggle(void) : "Toggle - If open, close. If closed, open."
	input SetDefaultTargetEntity(string) : "Sets the entity for the camera to track when it has nothing better to track, by name."
	input SetTargetEntity(string) : "Sets the entity for the camera to track now, by name."
	input SetAngry(void) : "Causes the camera to become angry as if it has seen something upsetting."
	input SetIdle(void) : "Causes the camera to calm down if it is angry."
	
	output OnFoundPlayer(string) : "Fired when the player is spotted within the inner radius"
	output OnFoundEnemy(void) : "Fired when a non-player enemy is spotted within the inner radius."
]


@PointClass base(Parentname, Targetname, Angles, Global) studio( "models/turrets/ground/turret.mdl" ) = npc_turret_ground : "Ground turret"
[
	input Enable(void) : "Turn turret on."
	input Disable(void) : "Turn turret off."

	output OnAreaClear(void) : "Fires when the turret can't find any more enemies (7 second delay)"
]

@PointClass base(Targetname, Angles, Global) studio( "models/turrets/ceiling/turret.mdl" ) = npc_turret_ceiling : "Ceiling Turret"
[
	spawnflags(Flags) = 
	[
		32 : "Autostart" : 1
		64 : "Start Inactive" : 0
		128 : "Never Retire" : 0
	]

	minhealthdmg(integer) : "Min req'd damage for hurting turret" : 0		

//	 Inputs
	input Enable(void) : "If closed, open."
	input Disable(void) : "If open, close."
	input Toggle(void) : "Toggle - If open, close. If closed, open."

//	 Outputs
	output OnDeploy(void) : "Turret is becoming active and dangerous."
	output OnRetire(void) : "Turret is becoming inactive and harmless."
	output OnTipped(void) : "Turret has been tipped over and is inactive."
]


@PointClass base(Targetname, Angles, Global) studio( "models/turrets/floor/turret.mdl" ) = npc_turret_floor : "Floor Turret"
[
	spawnflags(Flags) = 
	[
		32 : "Autostart" : 0
		64 : "Start Inactive" : 0
		128 : "Fast Retire" : 0
	]

//	 Inputs
	input Toggle(void) : "Toggle - If open, close. If closed, open."
	input Enable(void) : "Enable the turret."
	input Disable(void) : "Disable the turret."

//	 Outputs
	output OnDeploy(void) : "Turret is bmap ecoming active and dangerous."
	output OnRetire(void) : "Turret is becoming inactive and harmless."
	output OnTipped(void) : "Turret has been tipped over and is inactive."
	output OnPhysGunPickup(void) : "Picked up with physgun"
	output OnPhysGunDrop(void) : "Released by physgun"
]

//-----------------------------------------------------------------------------
// Begin SIN 

@NPCClass base(BaseNPC) studio("models/missile_defense.mdl") = npc_missiledefense : "Missile Defense"
[
]

@NPCClass base(BaseNPC) studio("models/crow.mdl") = npc_crow : "Crow"
[
	input FlyAway( string ) : "Forces the crow to fly to the nearest crow flyto hint node."
]

@NPCClass base(BaseNPC) studio("models/seagull.mdl") = npc_seagull : "Seagull"
[
	input FlyAway( string ) : "Forces the seagull to fly to the nearest crow flyto hint node."
]

@NPCClass base(BaseNPC) studio("models/pigeon.mdl") = npc_pigeon : "Pigeon"
[
	input FlyAway( string ) : "Forces the pigeon to fly to the nearest crow flyto hint node."
]
@NPCClass base(Parentname, BaseNPC) iconsprite("editor/bullseye.vmt") color(255 0 0) = npc_bullseye : "Bullseye"
[
//	 Unlike other NPCs level designers are allowed to set the health on bullseyes
	health(Integer) : "Health" : 35

	spawnflags(Flags) = 
	[
		65536   : "Not Solid" : 0
		131072  : "Take No Damage" : 0
		262144  : "Enemy Damage Only" : 0
		524288  : "Bleed" : 0
		1048576 : "Perfect Accuracy" : 0
	]
	output OnTargeted(void) : "Fires when targeted"
	output OnReleased(void) : "Fires when no longer targeted"
]


@NPCClass base(Parentname, BaseNPC) size(-16 -16 -16, 16 16 16) color(255 150 0) = npc_enemyfinder : "EnemyFinder"
[
	spawnflags(flags) =
	[
		65536 : "Check Visibility" : 1
		131072 : "APC Visibility checks" : 0
		262144 : "Short memory" : 0
		524288  : "Can be an enemy" : 0
	]
	FieldOfView(string) : "FieldOfView" : "0.2" : "How far to look (1.0 = straight ahead, 0.0 = +/- 90 degrees, -1.0 = all directions)"
	MinSearchDist(integer) : "Min Search Dist" : 0
	MaxSearchDist(integer) : "Max Search Dist" : 2048

	freepass_timetotrigger(float) : "Player pass issue time" : 0 : "Amount of time an enemy is hidden after which a 'free pass' on reaquire is granted"
	freepass_duration(float) : "Player pass duration" : 0 : "After granted 'free pass', the amount of time a target is allowed before reaquire"
	freepass_movetolerance(float) : "Player pass move tolerance" : 120 : "After granted 'free pass', the distance the target is allowed to move before reaquire"
	freepass_refillrate(float) : "Player pass refill rate" : "0.5" : "After free pass begins expiring, how much the time the target gets back for every second they hide again"
	freepass_peektime(float) : "Player pass peek time" : 0 : "How long targets in cover are allowed to peek without penalty"

	StartOn(choices) : "Start On" : 1 =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input TurnOn(void) : "Turn on: Look for enemies"
	input TurnOff(void) : "Turn off: Stop looking for enemies"
]

@PointClass base(Parentname, BaseNPC) studio("models/junk/w_traffcone.mdl") = npc_launcher : "Launcher"
[

	spawnflags(Flags) = 
	[
		65536  :  "Check LOS" : 1
	]

	StartOn(choices) : "Start On" : 0 = 
	[
		0: "Off"
		1: "On"
	] 
	MissileModel(studio) : "Missile Model" : "models/Weapons/wscanner_grenade.mdl"
	LaunchSound(sound) : "Launch Sound" : "weapons/rocket/rocket_fire.wav"
	FlySound(sound) :	"Fly Sound": "weapons/rocket/rocket1.wav"

	SmokeTrail(choices) : "Smoke Trail" : 1 = 
	[
		0: "Off"
		1: "On"
		2: "On Homing"
	] 
	LaunchSmoke(choices) : "Launch Smoke" : 1 = 
	[
		0: "Off"
		1: "On"
	] 
	LaunchDelay(integer) : "Launch Delay" : 8	    : "When ON, how long to wait between each launch"
	LaunchSpeed(string) : "Launch Speed" : 200   : "Initial launch speed of missile (in up direction)"
	PathCornerName(target_destination) : "Path Corner Name" : "" : "Name of a path corner.  If set launches a pathfollowing missing, rather than a homing missile"
	HomingSpeed(string) : "Homing Speed" : 0	    : "Speed to reach when homing"
	HomingStrength(integer) : "Homing Strength" : 10    : "How strong in homing effect (0-100)"
	HomingDelay(string) : "Homing Delay" : 0 : "Number of seconds to delay before homing starts"
	HomingRampUp(string) : "Homing Ramp Up" : "0.5" : "Number of seconds it takes to reach full homing strength after homing delay"
	HomingDuration(string) : "Homing Duration" : 5     : "Number of seconds the homing effect lasts"
	HomingRampDown(string) : "Homing Ramp Down" : "1.0" : "Number of seconds it takes homing effect to decay after homing duration"
	Gravity(string) : "Gravity" : "1.0" : "Scale for effect of gravity. (1.0 = normal gravity)"
	MinRange(integer) : "Min Range" : 100   : "Minimun distance a target can be to be attacked"
	MaxRange(integer) : "Max Range" : 2048  : "Maximum distance a target can be to be attacked"
	SpinMagnitude(string) : "Spin Magnitude" : 0	    : "Strength of spin in missile trajectory"
	SpinSpeed(string) : "Spin Speed" : 0     : "How fast does the spin rotate through 360"
	Damage(string) : "Damage" : 50    : "How much damage does each missile do"
	DamageRadius(string) : "DamageRadius" : 200   : "How far away from impact does the missle do damage"

//	 Outputs
	output OnLaunch(void) : "Fires when missile is launched"

//	 Inputs
	input TurnOn(void) : "Turn on Launcher"
	input TurnOff(void) : "Turn off Launcher"
	input LOSCheckOn(void) : "Start checking line of sight before firing"
	input LOSCheckOff(void) : "Stop checking line of sight before firing"
	input SetEnemyEntity(string) : "Set entity I should attack. Ignores visibility. (output from other entity only)"
	input ClearEnemyEntity(void) : "Clear set enemy enemy"
	input FireOnce(void) : "Fire Once (if have enemy)"
]

@PointClass base(Targetname, Parentname, Targetname, EnableDisable) = env_gunfire : "Gunfire Effect"
[
	target(target_destination) : "Target" : "" : "Shoot at this target. REMEMBER - this is an effect only! It does not do damage!"

	minburstsize(integer) : "Min Burst Size" : 2 : "Minimum number of rounds in a burst."
	maxburstsize(integer) : "Max Burst Size" : 7 : "Maximum number of rounds in a burst."

	minburstdelay(float) : "Min Delay Between Bursts" : 2 : "Minimum delay between bursts. (seconds)"
	maxburstdelay(float) : "Max Delay Between Bursts" : 5 : "Maximum delay between bursts. (seconds)"

	rateoffire(float) : "Rate of fire" : 10 : "Expressed as rounds per second"

	spread(choices) : "Bullet spread" : 5 : "The 'cone of inaccuracy' of the shots fired by this entity." =
	[
		1 : "1 Degree"
		5 : "5 Degrees"
		10 : "10 Degrees"
		15 : "15 Degrees"
	]

	bias(choices) : "Bullet distribution should be..." : 1 : "How to distribute bullets within the spread. Even distribution is a true scatter throughout the spread. Biased towards the outside makes the shots 'miss' the target by tending towards the outside of the spread." =
	[
		1 : "Evenly distributed"
		-1 : "Biased towards the outside"
	]

	collisions(choices) : "Collision detection" : 0 : "Whether/how to handle bullet collision detection. NOTE: If you select NONE, this entity will be very cheap to use, but all bullets will stop short at their target's position in space and there will be no impact effects. Normal collision detection does the same things NPCs do when they fire their guns (except harm anything)." =
	[
		0 : "None. Cheap for performance."
		1 : "Normal collision detection."
	]

	shootsound(string) : "Shoot Sound" : "Weapon_Assault.NPC_Single" : "Gunfire sound to make"
	tracertype(string) : "Tracer" : "" : "Type of tracer to display"
]

@NPCClass base(BaseNPC) = npc_spotlight : "Spotlight"
[
	spawnflags(Flags) = 
	[
		65536  :  "Start Track On" : 1
		131072 :  "Start Light On" : 1
		262144 :  "No Dynamic Light" : 0
		524288 :  "Never Move" : 0
	]

	health(Integer) : "Health" : 100
	YawRange(integer) : "YawRange" : 90
	PitchMin(integer) : "PitchMin" : 35
	PitchMax(integer) : "PitchMax" : 50
	IdleSpeed(integer) : "IdleSpeed" : 2
	AlertSpeed(integer) : "AlertSpeed" : 5
	spotlightlength(integer) : "SpotlightLength" : 500
	spotlightwidth(integer) : "SpotlightWidth" : 50
	rendercolor(color255) : "Color (R G B)" : "255 255 255"
	
//	 Inputs
	input LightOn(void) : "LightOn"
	input LightOff(void) : "LightOff"
	input TrackOn(void) : "TrackOn"
	input TrackOff(void) : "TrackOff"

//	 Outputs
	output OnAlert(void) : "Fires when the spotlight alerted by sound"
	output DetectedEnemy(string) : "Outputs enemy entity when spotlight finds and starts tracking enemy"
	output LostEnemy(string) : "Outputs enemy entity when spotlight loses enemy that it's tracking, if enemy still exists"
	output SquadDetectedEnemy(string) : "Outputs enemy entity when squad finds and starts tracking enemy"
	output SquadLostEnemy(string) : "Outputs enemy entity when squad loses enemy that it's tracking, if entity still exists"
	output LightPosition(string) : "Position of the end of the spotlight beam"
]
@PointClass base(Targetname, Parentname) iconsprite("editor/info_target.vmt")  = info_target_crash : "Helicopter Crash Target"
[
	input Enable(void) : "Enable the crash target."
	input Disable(void) : "Disable the crash target."
]
@PointClass base(Targetname, Parentname) iconsprite("editor/env_firesource") color(255 255 0) sphere(radius) = npc_heli_avoidsphere : "Helicopter avoidance sphere"
[
	spawnflags(Flags) = 
	[
		65536 :  "Avoid the sphere above and below" : 0
	]
	radius(float) : "Radius" : 128
]

@SolidClass base(Origin, Angles, Parentname) color(255 255 0) = npc_heli_avoidbox : "Helicopter avoidance box"
[
	spawnflags(Flags) = 
	[
		65536 :  "Avoid the box above and below" : 0
	]
]

@SolidClass base(Origin, Angles, Parentname) color(255 255 0) = npc_heli_nobomb : "Helicopter bombing suppressor"
[
]

@PointClass base(BaseNPC, RenderFields, Shadow) studio() = monster_generic : "Generic Script NPC"
[
	spawnflags(Flags) = 
	[
		65536 : "Not solid" : 0
	]
	model(studio) : "Model"
	body(Integer) : "Body" : 0
]


@PointClass base(BaseNPC, Parentname, RenderFields, Shadow) studio() = generic_actor : "Generic Actor NPC"
[
	model(studio) : "Model"

	hull_name(choices) : "Hull type" : "Human" =
	[
		"HUMAN_HULL" : "Human"
		"WIDE_HUMAN_HULL" : "Wide"
		"TINY_HULL" : "Tiny"
		"MEDIUM_HULL" : "Medium"
		"LARGE_HULL" : "Large"
	]
]

@PointClass base(BaseNPC, RenderFields, Shadow) studio() = cycler_actor : "Actor Cycler"
[
	model(studio) : "Model"
	Sentence(string) : "Sentence Group" : ""

	input Alpha(integer) : "Set Alpha Value"
]

@PointClass base(Angles, BaseNPCMaker) iconsprite("editor/npc_maker.vmt") = npc_maker : "NPC Maker"
[
	spawnflags(Flags) = 
	[
		16 : "Fade Corpse" : 0
	]

	NPCType(npcclass) : "Class name of spawned NPC"
	NPCTargetname(string) : "Childrens' Name"
	NPCSquadname(string) : "Childrens' Squad Name"
	NPCHintGroup(string) : "Childrens' Hint Group"
	
	additionalequipment(choices) : "Weapons" : "0" =
	[
		"weapon_pistol" : "Pistol"
		"weapon_ar2" : "AR2"
		"weapon_shotgun" : "Shotgun"
		"weapon_smg1" : "SMG1"
		"weapon_stunstick" : "Stun Stick"
		"weapon_annabelle"	:"Grigori's Shotgun"
		"0" : "Nothing"
	]
]

//-------------------------------------------------------------------------
//
// Player Control Entities
//
//-------------------------------------------------------------------------

@BaseClass base(Targetname) size(-10 -10 -10, 10 10 10) color(255 0 255) = player_control
[
//	 Inputs
	input Activate(void) : "Turns on"
	input Deactivate(void) : "Turns off"
	input SetThrust(string) : "Set Thrust"
	input SetSideThrust(string)  : "Set Side Thrust"
]

 
//-------------------------------------------------------------------------
//
// Scripted Events
//
//-------------------------------------------------------------------------

@BaseClass base(Targetname, Parentname, Angles) color(255 0 255) sphere(m_flRadius) = BaseScripted
[
	m_iszEntity(target_destination) : "Target NPC" : : "The name or class name (such as 'npc_leperkin') of an NPC to use for this script."
	m_iszIdle(string) : "Pre Action Idle Animation" : "" : "The name of the sequence (such as 'idle01') or activity (such as 'ACT_IDLE') to play before the action animation if the NPC must wait for the script to be triggered. Use 'Start on Spawn' flag or MoveToPosition input to play this idle animation."
	m_iszPlay(string) : "Action Animation" : "" : "The name of the main sequence (such as 'reload02') or activity (such as 'ACT_RELOAD') to play."
	m_iszPostIdle(string) : "Post Action Idle Animation" : "" : "The name of the sequence (such as 'idle01') or activity (such as 'ACT_IDLE') to play after the action animation."
	m_iszCustomMove(string) : "Custom Move Animation" : "" : "Used in conjunction with the 'Custom movement' setting for the 'Move to Position' property, specifies the sequence (such as 'crouch_run01') or activity (such as 'ACT_RUN') to use while moving to the scripted position."
	m_flRadius(integer) : "Search Radius (0=everywhere)" : 0 : "Radius to search within for an NPC to use. 0 searches everywhere."
	m_flRepeat(integer) : "Repeat Rate ms" : 0
	m_fMoveTo(Choices) : "Move to Position" : 1 =
	[
		0 : "No"
		1 : "Walk"
		2 : "Run"
		3 : "Custom movement"
		4 : "Instantaneous"
		5 : "No - Turn to Face"
	]
	m_iszNextScript(target_destination) : "Next Script" : : "The name of the script to run immediately after this script completes. The NPC will not return to AI between the two scripts."

//	 Inputs
	input BeginSequence(void) : "Summons an NPC to act out the scripted sequence."
	input MoveToPosition(void) : "Summons an NPC to the script location. They will play their scripted idle (or ACT_IDLE if none is specified) until BeginSequence is triggered."
	input CancelSequence(void) : "Stops the scripted sequence. If fired after a sequence starts, this input will not take effect until the NPC finishes playing the scripted action animation."

//	 Outputs
	output OnBeginSequence(void) : "Fires when the action animation begins playing."
	output OnEndSequence(void) : "Fires when the action animation completes."
	output OnScriptEvent01(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 1 } in the QC."
	output OnScriptEvent02(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 2 } in the QC."
	output OnScriptEvent03(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 3 } in the QC."
	output OnScriptEvent04(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 4 } in the QC."
	output OnScriptEvent05(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 5 } in the QC."
	output OnScriptEvent06(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 6 } in the QC."
	output OnScriptEvent07(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 7 } in the QC."
	output OnScriptEvent08(void) : "Fires when a 'trigger' anim event occurs while playing the script. Use { event 1003 framenum 8 } in the QC."
]

@PointClass sphere() iconsprite("editor/scripted_sentence.vmt") base(Targetname) = scripted_sentence : "Scripted Sentence"
[
	spawnflags(Flags) = 
	[
		1 : "Fire Once"  : 1
		2 : "Followers Only" : 0
		4 : "Interrupt Speech" : 1
		8 : "Concurrent" : 0
		16 : "Speak to Activator" : 1
	]

	sentence(string) : "Sentence Name" : ""
	entity(string) : "Speaker Type"
	delay(string) : "Additional Sentence Time" : "0"
	radius(integer) : "Search Radius" : 512
	refire(string) : "Delay Before Refire" : "3"
	listener(string) : "Listener Type"
	volume(string) : "Volume 0-10" : "10"
	attenuation(Choices) : "Sound Radius" : 0 =
	[
		0 : "Small Radius"
		1 : "Medium Radius"
		2 : "Large  Radius"
		3 : "Play Everywhere"
	]

//	 Inputs
	input BeginSentence(void) : "Starts the scripted sentence."

//	 Outputs
	output OnBeginSentence(void) : "Fires when the sentence begins"
	output OnEndSentence(void) : "Fires when the sentence ends"
]

@PointClass base(Targetname, Parentname) iconsprite("editor/info_target.vmt")  = scripted_target : "Scripted Target"
[
	StartDisabled(choices) : "Start Disabled" : 1 =
	[
		0 : "No"
		1 : "Yes"
	]

	m_iszEntity(npcclass) : "Target NPC"
	m_flRadius(integer) : "Search Radius (0=everywhere)" : 0 : "Radius to search within for an NPC to use. 0 searches everywhere."

	MoveSpeed(integer) : "Move Speed" : 5		//	 How quickly should target move between scripted targets
	PauseDuration(integer) : "Pause Duration" : 0	//	 How long should target pause at scripted target
	EffectDuration(integer) : "Effect Duration" : 2	//	 How long should any associated effect last

	target(target_destination) : "Next Target"	//	 Next scripted target

//	 Inputs
	input Enable(void) : "Enable this entity"
	input Disable(void) : "Disable this entity"

//	 Outputs
	output AtTarget(void) : "Fires when NPC reaches this target"
	output LeaveTarget(void) : "Fires when NPC leaves this target"
]

@PointClass base(Targetname) iconsprite("editor/ai_relationship.vmt") sphere() = ai_relationship : 
	"AI Relationship - Sets relationships between groups of NPCs in the AI."
[
	subject(target_name_or_class) : "Subject(s)" : "" : "This is the NPC(s) whose disposition will change. May be a targetname or a classname."
	target(target_name_or_class) : "Target(s)" : "" : "This is the NPC(s) about whom the Subject(s) will change their disposition. May be a tarGetname or a classname."
	disposition(choices) : "Disposition" : 3 : "Choose the way the Subject(s) should feel about the Target(s)" =
	[
	//	 These MUST match the enum in the code! (basecombatcharacter.h)
		1 : "Hate"
		2 : "Fear"
		3 : "Like"
		4 : "Neutral"
	]

	radius(float) : "Radius for subject" : 0

	rank(integer) : "Disposition Priority" : 0 : "How much the Subject(s) should Like/Hate/Fear the Target(s). Higher priority = stronger feeling."

	StartActive(choices) : "Start Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	Reciprocal(choices) : "Reciprocal" : 0 : "Set this to YES to have the new relationship mirrored by Target"  =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input ApplyRelationship(void) : "Apply relationship changes"
	input RevertRelationship(void) : "Revert relationship changes"
]

@PointClass base(Targetname) = ai_ally_manager : "AI Ally Manager"
[
	maxallies(integer) : "Maximum number of allies" : 5
	maxmedics(integer) : "Maximum number of medics" : 1

//	 Inputs
	input SetMaxAllies(integer) : "Set maximum number of allies"
	input SetMaxMedics(integer) : "Set maximum number of medic allies"
	input Replenish(void) : "Replenish player allies"

//	 Outputs
	output SpawnMedicAlly(void) : "Spawn Medic Ally"
	output SpawnAlly0(void) : "Spawn Ally 0"
	output SpawnAlly1(void) : "Spawn Ally 1"
	output SpawnAlly2(void) : "Spawn Ally 2"
	output SpawnAlly3(void) : "Spawn Ally 3"
	output SpawnAlly4(void) : "Spawn Ally 4"
	output SpawnAlly5(void) : "Spawn Ally 5"
	output SpawnAlly6(void) : "Spawn Ally 6"
	output SpawnAlly7(void) : "Spawn Ally 7"
	output SpawnAlly8(void) : "Spawn Ally 8"
	output SpawnAlly9(void) : "Spawn Ally 9"

	output OnZeroAllies(void) : "Fires when there are no more allies"
	output OnZeroMedicAllies(void) : "Fires when there are no more allies"
]

@BaseClass base(Targetname) = LeadGoalBase
[
	actor(target_name_or_class) : "Actor(s) to affect"
	goal(string) : "Target Entity"
	WaitPointName(target_destination) : "Point to wait at if the target's not visible."
	WaitDistance(float) : "Wait until player gets this close."
	LeadDistance(float) : "Lead Distance." : "64" : "The player is considered to be lagging if he's beyond this distance."
	Run(choices) : "Run instead of Walk" : "0" =
	[
		"0" : "No"
		"1" : "Yes"
	]

	Retrieve(choices) : "Retrieve player?" : 1 =
	[
		0 : "No, just idle and wait"
		1 : "Yes, move to retrieve"
	]
	
	AttractPlayerConceptModifier(string) : "Attract player concept modifier"
	WaitOverConceptModifier(string) : "Player wait over concept modifier"
	ArrivalConceptModifier(string) : "Arrival concept modifier"
	PostArrivalConceptModifier(string) : "Post-arrival concepts modifier"
	SuccessConceptModifier(string) : "Success concept modifier"
	FailureConceptModifier(string) : "Failure concept modifier"
	
//	 Spawnflags
	spawnflags(Flags) = 
	[
		1 : "No def success" : 0
		2 : "No def failure" : 0
		4 : "Use goal facing" : 1
	]

//	 Inputs
	input Activate( void )  : "Begin the leading behavior"
	input Deactivate( void )  : "Stop the leading behavior"
	
	input SetSuccess( void ) : "Notify success of leading"
	input SetFailure( void ) : "Notify failure of leading"
	
//	 Outputs
	output OnArrival( void ) : "Fires when NPC reaches the lead point"
	output OnArrivalDone( void ) : "Fires when NPC has played out any arrival speech"
	output OnSuccess( void ) : "Fires when NPC achieves the goal"
	output OnFailure( void ) : "Fires when NPC fails to achieves the goal"
	output OnDone( void ) : "Fires when NPC completes behavior (any post-success or fail acting is complete)"
]


@PointClass base(LeadGoalBase) iconsprite("editor/ai_goal_lead.vmt") = ai_goal_lead : "AI Goal Lead"
[
	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 
]

@PointClass base(LeadGoalBase) iconsprite("editor/ai_goal_lead.vmt") = ai_goal_lead_weapon : 
	"AI Goal Lead (Weapon). A version of the ai_goal_lead entity that requires the player to have the specified weapon before the Actor(s) will lead the player to their target."
[
	WeaponName(choices) : "Weapon" : "weapon_bugbait" =
	[
		"weapon_bugbait" : "Bugbait"
		"weapon_smg1" : "SMG1"
		"weapon_ar2"  : "AR2"
	]

	MissingWeaponConceptModifier(string) : "Missing weapon concept modifier"
	
	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 
]

@PointClass base(Targetname) iconsprite("editor/ai_goal_follow.vmt") = ai_goal_follow : "AI Goal Follow"
[
	actor(target_name_or_class) : "Actor(s) to affect"
	goal(string) : "Target Entity" : : "The name of the entity to follow. If blank, and the actor likes the player, then defaults to player"

	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 

	StartActive(choices) : "Start Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	MaximumState(choices) : "Maximum state" : 1 =
	[
		1 : "Idle"
		2 : "Alert"
		3 : "Combat"
	]

	Formation(choices) : "Formation" : 0 =
	[
		0 : "Close circle"
		1 : "Wide circle"
		5 : "Medium circle"
	]

//	 Inputs
	input Activate( void ) : "Begin the follow behavior"
	input Deactivate( void ) : "Cease the follow behavior"
]

@PointClass size( -4 -4 -4, 4 4 4 ) base(Targetname, Angles, Parentname) studio("models/pigeon.mdl") = ai_battle_line : "Battle line"
[																									  
//	 Spawnflags
	spawnflags(Flags) = 
	[
		1 : "Use parent's orientation" : 0
	]

	actor(target_name_or_class) : "Actor(s) or squad to affect"

	Active(choices) : "Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	Strict(choices) : "Strict" : 1 : "Player orders can override, applies to allies only" =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input Activate(void)
	input Deactivate(void)
]


@PointClass base(Targetname) iconsprite("editor/ai_take_cover.vmt") = ai_goal_takecover : "AI Take Cover"
[
    actor(target_name_or_class) : "Actor(s) to affect"
    
	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 

	StartActive(choices) : "Start Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

//	HintGroupChangeReaction(Choices) : "Reaction to tactical change" : 1 : "What to do if leader moves, threat is neutralized, hint group changes, etc" =
//	[
//		0 : "Move when ready (default AI)"
//		1 : "Move when seek cover"
//		2 : "Move immediately"
//	]

//	AbandonIfEnemyHides(choices) : "Abandon if enemies hide" : 0 : "If no enemy detected recently, stop taking cover" =
//	[
//		0 : "No"
//		1 : "Yes"
//	]

//	 Inputs
	input Activate( void ) : "Begin taking cover"
	input Deactivate( void ) : "Cease taking cover"
	input Toggle( void ) : "Toggle taking cover"
]

@PointClass base(Targetname) iconsprite("editor/ai_goal_standoff.vmt") = ai_goal_standoff : "AI Goal Standoff"
[
	actor(target_name_or_class) : "Actor(s) to affect"
//	goal(string) : "Target Entity (self by default) [NOT IMPLEMENTED]"

	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 

	StartActive(choices) : "Start Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	HintGroupChangeReaction(Choices) : "Reaction to tactical change" : 1 : "What to do if leader moves, threat is neutralized, hint group changes, etc" =
	[
		0 : "Move when ready (default AI)"
		1 : "Move when seek cover"
		2 : "Move immediately"
	]

	Aggressiveness(Choices) : "Aggressiveness" : 2 =
	[
		0 : "Very low"
		1 : "Low"
		2 : "Medium"
		3 : "High"
		4 : "Very High"
	//	 Custom agression disabled
	//	 		100 : "Custom"
	]

	PlayerBattleline(choices) : "Player battleline" : 1 : "Player defines a battle line, applies to allies only" =
	[
		0 : "No"
		1 : "Yes"
	]

	StayAtCover(choices) : "Stay at cover location" : 0 : "When have suitable cover, don't change it (disables advancing to battle line)" =
	[
		0 : "No"
		1 : "Yes"
	]

	AbandonIfEnemyHides(choices) : "Abandon if enemies hide" : 0 : "If no enemy detected recently, stop the standoff" =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Custom aggression
//	CustomCoverOnReload(choices) : "Custom: Take cover to reload" : 1 =
//	[
//		0 : "No"
//		1 : "Yes"
//	]
//	CustomMinTimeShots(float) : "Custom: Min time wait to shoot"	  : 2 : "Minimum duration of time after a burst of shooting before trying again"
//	CustomMaxTimeShots(float) : "Custom: Max time wait to shoot"	  : 4 : "Minimum duration of time after a burst of shooting before trying again"
//	CustomMinShots(integer) : "Custom: Min shots in a burst"	  : 1
//	CustomMaxShots(integer) : "Custom: Max shots in a burst"	  : 4
//	CustomOddsCover(integer) : "Custom: Odds cover on damage"	  : 25 : "If damaged, the chances react by taking immediate cover"

//	 Inputs
	input Activate( void ) : "Begin contesting position"
	input Deactivate( void ) : "Cease contesting position"
	input SetAggressiveness(integer) : "Set aggressiveness"
]

@PointClass base(Targetname, Parentname, Angles) sphere(policeradius) iconsprite("editor/ai_goal_police.vmt") = ai_goal_police : "AI Goal Police"
[
	spawnflags(Flags) = 
	[
		2 : "Knock-out target past crossing plane" : 0
		4 : "Do not leave post" : 0
	]

	policeradius(float) : "Radius" : 512 : "Radius to police"
	policetarget(string) : "Target" : "" : "Target to police"

//	 Inputs
	input EnableKnockOut(void) : "Tells the goal to make the active policing NPC knock out its target"
	input DisableKnockOut(void) : "Stop the active policing NPC from trying to knock out its target"

//	 Outputs
	output OnFirstWarning(void) : "Fires the first time a policing cop warns a target"
	output OnSecondWarning(void) : "Fires the second time a policing cop warns a target"
	output OnLastWarning(void) : "Fires when a policing cop warns a target for the last time"
	output OnSupressingTarget(void) : "Fires when a policing cop starts to suppress (ie. beat) a target"
	output OnKnockOut(void) : "Fires when a target has been knocked out"
]

@PointClass base(Targetname, Parentname, Angles) iconsprite("editor/assault_rally.vmt") line(255 255 255, targetname, assaultpoint) = assault_rallypoint : 
	"(Assault) rally point"
[
	assaultpoint(target_destination)  : "Assault Point" : "" : "Location to move to as assault begins"
	assaultdelay(float) : "Assault Delay" : 0 : "How long to wait after cue is given before assault begins."
	rallysequence(string) : "Rally Sequence" : "" : "Override the NPC's wait activity by entering a sequence name."
	priority(integer) : "Priority" : 1 : "Higher priority rally points get selected first."

	output OnArrival(void) : "Fires when the NPC reaches this rally point"
]

@PointClass base(Targetname, Parentname, Angles) iconsprite("editor/assault_point.vmt") line(255 255 255, targetname, nextassaultpoint) = assault_assaultpoint : 
	"(Assault) assault point"
[
	assaultgroup(string)  : "Assault Hint Group" : "" : "NPC's movements are constrained to this hint group once assault has begun"
	nextassaultpoint(target_destination) : "Next assault point (optional)"
	assaulttimeout(float) : "Assault time out" : "3.0" : "This point is cleared when no enemies are seen for this long (seconds)"
	clearoncontact(choices) : "Clear on contact with enemies" : 0 : "If you come in contact with enemies while approaching the assault point, clear our assault point" =
	[
		0 : "No"
		1 : "Yes"
	]
	allowdiversion(choices) : "Allow diversion" : 0 : "If you come in contact with enemies while approaching the assault point, divert to kill them. Resume the assault once contact is lost." =
	[
		0 : "No"
		1 : "Yes"
	]

	nevertimeout(choices) : "Never Timeout" : 0 : "If set, the assault never ends for NPCs assaulting this point. Useful for forcing NPCs back to a point." =
	[
		0 : "No"
		1 : "Yes"
	]

	spawnflags(Flags) = 
	[
		1 : "Clear this point upon arrival, UNCONDITIONALLY" : 0
	]

//	 Inputs
	input SetClearOnContact(integer) : "Set the clear on contact flag."
	input SetAllowDiversion(integer) : "Set the allow diversion flag."

//	 Outputs
	output OnArrival(void) : "Fires when the NPC reaches this assault point"
	output OnAssaultClear(void) : "Fires when this assault point is cleared of enemies"
]

@PointClass base(Targetname) = ai_goal_assault : 
	"AI Goal Assault"
[
	actor(target_name_or_class) : "Actor(s) to affect" : "" : "NPC's that should perform this assault"
	rallypoint(target_destination) : "Rally Point Set" : "" : "Root name of rally points for this assault. Use an asterisk '*' after the root name to match all with the same root."

	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 

	StartActive(choices) : "Start Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	AssaultCue(choices) : "Assault Cue" : 1 =
	[
		1 : "Entity System Input"
		2 : "Gunfire"
		3 : "Don't wait for a cue."
	]

//	 Inputs
	input Activate( void ) : "Begin the assault behavior"
	input Deactivate( void ) : "Cease the assault behavior"
	input BeginAssault( void ) : "Begin assault phase"
]

@BaseClass base(Targetname) = BaseActBusy
[
	actor(target_name_or_class) : "Actor(s) to affect" : "" : "NPC's that should act busy"

	StartActive(choices) : "Start Active" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	SearchType(choices) : "Search Type" : 0 : "How to search for the entities using the targetname." = 
	[
		0 : "Entity Name"
		1 : "Classname"
	] 

	busysearchrange(float) : "Search Range for Busy Hints" : 2048
	visibleonly(choices) : "Visible Busy Hints Only" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input Activate( void ) : "Begin acting busy"
	input Deactivate( void ) : "Cease acting busy"
	input SetBusySearchRange( float ) : "Update the busy search range for all actors."
	input ForceNPCToActBusy( string ) : "Force an NPC to act busy. Takes parameters, separated by spaces: <Targetname> <hint node targetname> <optional:teleport> <optional:$customactivityorsequence> <maximum time to actbusy>. If no hint node targetname is specified, it'll search for a random one. If no max time is specified, it'll use the default. Specifying 0 as the max time will make the NPC act busy until disturbed. If the optional teleport parameter is specified, the NPC will teleport to the act busy point. A custom move animation can be specified by prepending $ to the name of it. i.e. $ACT_RUN will make the NPC Run. Sequence names can be used instead of activities."
	input ForceThisNPCToActBusy( string ) : "Force an NPC outputted from another entity to act busy. (only usable from an output that specifies an entity)"
	input ForceThisNPCToLeave( string ) : "Force an NPC outputted from another entity to find a HINT_NPC_EXIT_POINT hintnode and vanish."

//	 Outputs
	output OnNPCStartedBusy(string) : "Fired when an NPC targeted by this goal starts an ActBusy animation."
	output OnNPCFinishedBusy(string) : "Fired when an NPC targeted by this goal finishes an ActBusy."
	output OnNPCLeft(string) : "Fired when an NPC target by this goal finishes a forced Leave."
]

@PointClass base(BaseActBusy) = ai_goal_actbusy : "AI Goal Act Busy"
[
]

@PointClass base(BaseActBusy) = ai_goal_actbusy_queue : "AI Goal Act Busy Queue"
[
	node_exit(target_destination) : "Exit Node" : "" : "The name of the node the first NPC in the queue should move to when he leaves the head of the queue."
	node01(target_destination) : "Node 1" : "" : "The name of the first actbusy hint node in the queue."
	node02(target_destination) : "Node 2" : "" : "The name of the second actbusy hint node in the queue."
	node03(target_destination) : "Node 3" : "" : "The name of the third actbusy hint node in the queue."
	node04(target_destination) : "Node 4" : "" : "The name of the fourth actbusy hint node in the queue."
	node05(target_destination) : "Node 5" : "" : "The name of the fifth actbusy hint node in the queue."
	node06(target_destination) : "Node 6" : "" : "The name of the sixth actbusy hint node in the queue."
	node07(target_destination) : "Node 7" : "" : "The name of the seventh actbusy hint node in the queue."
	node08(target_destination) : "Node 8" : "" : "The name of the eighth actbusy hint node in the queue."
	node09(target_destination) : "Node 9" : "" : "The name of the ninth actbusy hint node in the queue."
	node10(target_destination) : "Node 10" : "" : "The name of the tenth actbusy hint node in the queue."
	node11(target_destination) : "Node 11" : "" : "The name of the eleventh actbusy hint node in the queue."
	node12(target_destination) : "Node 12" : "" : "The name of the twelfth actbusy hint node in the queue."
	node13(target_destination) : "Node 13" : "" : "The name of the thirteenth actbusy hint node in the queue."
	node14(target_destination) : "Node 14" : "" : "The name of the fourteenth actbusy hint node in the queue."
	node15(target_destination) : "Node 15" : "" : "The name of the fifteenth actbusy hint node in the queue."
	node16(target_destination) : "Node 16" : "" : "The name of the sixteenth actbusy hint node in the queue."
	node17(target_destination) : "Node 17" : "" : "The name of the seventeenth actbusy hint node in the queue."
	node18(target_destination) : "Node 18" : "" : "The name of the eighteenth actbusy hint node in the queue."
	node19(target_destination) : "Node 19" : "" : "The name of the nineteenth actbusy hint node in the queue."
	node20(target_destination) : "Node 20" : "" : "The name of the twentieth actbusy hint node in the queue."
	 
	mustreachfront(choices) : "Must Reach Front" : 0 : "If true, NPCs much reach the front node in the queue before they're allowed to leave the queue." =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input PlayerStartedBlocking(float) : "Tell the queue manager that the player has started blocking a spot in the queue."
	input PlayerStoppedBlocking(float) : "Tell the queue manager that the player has stopped blocking a spot in the queue."
	input MoveQueueUp(void) : "Force the queue to move up, sending the front-most NPC out of the queue."

//	 Outputs
	output OnQueueMoved(float) : "Fired when the queue moves. Outputs the number of NPCs left in the queue."
	output OnNPCStartedLeavingQueue(string) : "Fired when the NPC at the head of the queue starts to leave. The activator is the NPC, and the string is the name of the NPC."
	output OnNPCLeftQueue(string) : "Fired when the NPC at the head of the queue leaves. The activator is the NPC, and the string is the name of the NPC."
]

@PointClass base(Targetname) size(-8 -8 -8, 8 8 8) = ai_changetarget : "Change Target"
[
	target(target_destination) : "Target entity" : : "Name of entity whose target will be changed."
	m_iszNewTarget(string) : "New Target"

//	 Inputs
	input Kill( void ) : "Removes this entity from the world"
	input Activate( void ) : "Changes the entities target"
]

@PointClass base(Targetname) sphere(Radius)  size(-8 -8 -8, 8 8 8) = ai_changehintgroup : "Change Hint Group"
[
	SearchType(choices) : "Search Type" : 0 : "How to search for the entities to change." = 
	[
		0 : "Entity Name"
		1 : "Classname"
		2 : "Old Hint Group"
	] 
	SearchName(string) : "Name to search for"
	NewHintGroup(string) : "New Hint Group"
	Radius(string) : "Search Radius" : "0.0" : "Radius to search (0 for all of map)"
	hintlimiting(choices) : "Hint Limit Nav" : 0 : "Limits NPC to using specified hint group for navigation requests, does not limit local navigation." =
	[
		0 : "No"
		1 : "Yes"
	]

	input Kill( void ) : "Removes this entity from the world"
	input Activate( void ) : "Change the Hint Group"
]



@PointClass base(Targetname) = ai_script_conditions : "AI Script Conditions"
[
	Actor(target_destination) : "Actor" : : "NPC Target"
	
	StartDisabled(choices) : "Start Disabled" : 1 =
	[
		0 : "No"
		1 : "Yes"
	]

	MinimumState(choices) : "Minimum state" : 1 =
	[
		1 : "Idle"
		2 : "Alert"
		3 : "Combat"
	]

	MaximumState(choices) : "Maximum state" : 3 =
	[
		1 : "Idle"
		2 : "Alert"
		3 : "Combat"
	]
	
	ScriptStatus(choices) : "Actor is running a script?" : 0 =
	[
		0 : "No"
		1 : "Yes"
		2 : "Don't care"
	]
		
	RequiredTime(float) : "Required Time"	  : 0 : "Duration of time that all the conditions must be true"
	DelayForCheckConditionsUnmet(float) : "DelayAfterConditionsMet" : 0 : "Delay to wait after Conditions being met for checking if the conditions are no longer being met.  This MUST be set for the ConditionsUnsatisfied output to EVER fire."
	MinTimeout(float) : "Minimum time out"  : 0 : "Minimum time before OnConditionsTimeout is fired. 0 = never expire"
	MaxTimeout(float) : "Maximum time out"  : 0 : "Maximum time before OnConditionsTimeout is fired. 0 = ignore"
	
	ActorSeePlayer(choices) : "Actor Sees Player" : 2 =
	[
		0 : "No"
		1 : "Yes"
		2 : "Don't care"
	]

	PlayerActorProximity(float) : "Player distance"  : 0 : "The distance the player must/must not be to the actor. Negative values for NOT, 0 for ignore."
	PlayerActorFOV(float) : "Player FOV for Actor " : 360 : "Specify angle of view cone in degrees. Negative value = NOT"
	PlayerActorFOVTrueCone(choices ) : "Play FOV to Actor is a true view cone" : 0 : "Player's view cone is evaluated as a true cone, not pie slice " = 
	[
		0 : "No - Tall pie slice"
		1 : "Yes - True view cone"
	]

	PlayerActorLOS(choices) : "Player has LOS to Actor" : 2 : "Checks that the player has clear Line of Sight to the Actor" =
	[
		0 : "No"
		1 : "Yes"
		2 : "Don't care"
	]


	target(target_destination) : "Target (Optional)" : : "Optional entity to include in conditions"
	ActorSeeTarget(choices)  : "Actor Sees Target" : 2 =
	[
		0 : "No"
		1 : "Yes"
		2 : "Don't care"
	]

	ActorTargetProximity(float) : "Target distance"  : 0 : "The distance the actor must/must not be to the Target. Negative values for NOT, 0 for ignore."
	PlayerTargetProximity(float) : "Player distance from Target"  : 0 : "The distance the player must/must not be to the Target. Negative values for NOT, 0 for ignore."
	PlayerTargetFOV(float) : "Player FOV for Target" : 360 : "Specify angle of view cone in degrees. Negative value = NOT"
	PlayerTargetFOVTrueCone(choices ) : "Play FOV to Target is a true view cone" : 0 : "Player's view cone is evaluated as a true cone, not pie slice " = 
	[
		0 : "No - Tall pie slice"
		1 : "Yes - True view cone"
	]

	PlayerTargetLOS(choices) : "Player has LOS to Target" : 2 : "Checks that the player has clear Line of Sight to the Target" =
	[
		0 : "No"
		1 : "Yes"
		2 : "Don't care"
	]
	
	PlayerBlockingActor(choices) : "Player blocking Actor" : 2 : "Checks that the player is blocking the Actor's path" =
	[
		0 : "No"
		1 : "Yes"
		2 : "Don't care"
	]

//	 Inputs
	input Enable(void) : "Enable this entity"
	input Disable(void) : "Disable this entity"

//	 Outputs
	output OnConditionsSatisfied(void) : "Fires when AI conditions satisfied"
	output OnConditionsTimeout(void)   : "Fires when AI conditions timed out"
	output OnConditionsUnsatisfied(void) : "Fires when AI conditions no longer satisfied after being satisfied.  This won't fire sooner than 3.0 seconds after conditions having been met."
]

@PointClass base(BaseScripted, Angles, DXLevelChoice) studio("models/editor/scriptedsequence.mdl") sphere(m_flRadius) = scripted_sequence :
	"Grabs an NPC and makes them play a specified set of animations. The NPC can be told to move to the scripted sequence position or can "+
	"be told to play the script wherever they currently are. "+
	"Multiple scripted sequences of the same name will frame-synchronize in the action animation once all the actors have moved to position. "+
	"This allows tight interaction between actors (one actor grabbing another, hitting them, etc.) The flow is as follows:\n\n"+
	"1) Move to position using the specified movement animation. If 'Move to Position' is set to NONE, skip to step 2.\n"+
	"2) If forced to wait for another actor to move to position, play the pre-action idle animation, otherwise skip to step 3. If there is no pre-action idle specified, ACT_IDLE is used.\n"+
	"3) Fire the OnBeginSequence output.\n"+
	"4) Play the action animation. If no action animation is specified, skip to step 5.\n"+
	"5) Play the post-action idle animation. If none is specified, skip to step 6. If the 'Loop in Post Idle' spawnflag is set, keep playing the post-action idle until the script is cancelled. If no post-action idle animation is specified, ACT_IDLE is used.\n"+
	"6) Fire the OnEndSequence output.\n"+
	"7) If a next script to play is specified, hand the NPC to the next script and repeat this process for that script.\n\n"+
	"The MoveToPosition input runs steps 1 and 2, then waits while playing the pre-action idle animation until the BeginSequence input is received."
[
	spawnflags(Flags) = 
	[
		4 : "Repeatable" : 0
		8 : "Leave Corpse" : 0
		16 : "Start on Spawn" : 0
		32: "No Interruptions" : 0
		64: "Override AI" : 0
		128: "No Script Movement" : 0
		256: "Loop in Post Idle" : 0
		512: "Priority Script" : 0
	]
]


@PointClass base(Targetname) sphere(m_flRadius) color(255 0 255) iconsprite("editor/aiscripted_schedule") = aiscripted_schedule :
	"Issues a command to an NPC without taking the NPC out of its AI. This does not seize control of the NPC as " +
	"a scripted_sequence does" 
[
	m_iszEntity(target_destination) : "Target NPC" : : "The name or classname of an NPC to use."
	m_flRadius(integer) : "Search Radius (0=everywhere)" : 0 : "Radius to search within for an NPC to use. 0 searches everywhere."

	graball(choices)  : "All in radius" : 0: "Whether to grab all matching NPCs in the specified radius, instead of just one"  =
	[
		0 : "No"
		1 : "Yes"
	]

	spawnflags(Flags) = 
	[
		4 : "Repeatable" : 0
		1024 : "Search Cyclically" : 0
		2048 : "Don't Complain" : 0
	]

	forcestate(choices) : "AI state to set" : 0 =
	[
		0 : "<None>"
		1 : "Set state to IDLE"
		2 : "Set state to ALERT"
		3 : "Set state to COMBAT"
	]
		
	schedule(choices) : "Schedule to run" : 1 =
	[
		0 : "<None>"
		1 : "Walk to Goal Entity"
		2 : "Run to Goal Entity"
		3 : "Set enemy to Goal Entity"
		4 : "Walk Goal Path"
		5 : "Run Goal Path"
		6 : "Set enemy to Goal Entity AND Run to Goal Entity"
	]
	
	interruptability(choices) : "Interruptability" : 0 =
	[
		0 : "General"
		1 : "Damage or Death"
		2 : "Death"
	]

	goalent(target_destination) : "Goal entity" : : "Provides the name of a schedule-specific goal entity (see 'Schedule to run')"

//	 Inputs
	input StartSchedule(void) : "Starts the scripted schedule. This will first locate an NPC that " +
		"matches the given target, then tell the NPC to run the specified schedule."
]

@PointClass base(Targetname) = ai_citizen_response_system :
	"If placed in the level, will manage citizens responses to player's actions."
[
//	 Inputs
	input ResponseVitalNPC(void) : "Fire the VitalNPC Died response."
]

//-------------------------------------------------------------------------
//
// Solid Entities
//
//-------------------------------------------------------------------------

@SolidClass base(EnableDisable, Parentname, Origin, Global) = func_healthcharger: "Wall health recharger" 
[
//	 dmdelay(integer) : "Deathmatch recharge delay" : 0
	_minlight(string) : "Minimum light level"

//	 Outputs
	output OutRemainingHealth(float) : "Remaining Health."
	output OnPlayerUse(void) : "Fired when the player +USEs the charger."
]

@SolidClass base(Targetname, Parentname, Origin) = func_recharge: "Battery recharger" 
[
//	 dmdelay(integer) : "Deathmatch recharge delay" : 0
	_minlight(string) : "Minimum light level"

	spawnflags(flags) =
	[
		8192  : "Citadel recharger" : 0
	]

//	 Inputs
	input Recharge(void) : "Recharge to full"

//	 Outputs
	output OutRemainingCharge(float) : "Remaining Charge."
	output OnHalfEmpty(void) : "Half-Empty"
	output OnEmpty(void) : "Empty"
	output OnFull(void) : "Recharged to full."
	output OnPlayerUse(void) : "Fired when the player +USEs the charger."
]

@SolidClass base(Parentname, Targetname, Global) = func_vehicleclip: "Vehicle Clip" 
[
	input Kill( void ) : "Removes this entity from the world"
]

@SolidClass base(func_movelinear) = func_lookdoor : "A door that moves either when looked by a targeted object or when " +
	"a target object comes near the door.  Behavior can be either based on viewing direction or proximity " +
	"alone, or on a combination of both.  If inverted the doors behavior will be the opposite." 
[
	spawnflags(flags) =
	[
		8192  : "LookDoor Threshold" : 0
		16384 : "LookDoor Invert" : 0
		32768 : "LookDoor From Open" : 0
	]

	ProximityDistance(string) : "Proximity Distance" : "0.0"  : "If non-zero, proximity range over which door will move"
	ProximityOffset(string) : "Proximity Offset" : "0.0" : "Offset from the target object"
	FieldOfView(string) : "FieldOfView" : "0.0"  : "If non-zero, field of view over which door will move"

//	 Input
	input InvertOn(void) : "InvertOn - when set behavior of door is inverted."
	input InvertOff(void) : "InvertOff - when set behavior of door is normal."
]

@SolidClass base(Trigger) = trigger_waterydeath: 
	"A trigger volume that spawns leeches around entities inside it, and does damage to them until they die. "+
	"Used to prevent players entering deep water."
[
]

//-------------------------------------------------------------------------
//
// Point Entities
//
//-------------------------------------------------------------------------

@PointClass base(EnvGlobal) size(-8 -8 -8, 8 8 8) = env_global : 
	"An entity to control a game-specific global states."
[
	globalstate(choices) : "Global State to Set" =
	[
		"gordon_precriminal" : "Gordon pre-criminal" 
		"antlion_allied" : "Antlions are player allies" 
//		"player_stealth" : "Player in APC is disguised as combine" 
		"suit_no_sprint" : "Suit sprint function not yet enabled" 
		"super_phys_gun" : "Super phys gun is enabled" 
		"friendly_encounter" : "Friendly encounter sequence (lower weapons, etc.)"
//		"citizens_passive" : "Citizens are *not* player allies (cannot be commanded)"
		"gordon_invulnerable" : "Gordon is invulnerable"
		"no_seagulls_on_jeep" : "Don't spawn seagulls on the jeep"
	]
]

//-------------------------------------------------------------------------
//
// Tanks
//
//-------------------------------------------------------------------------
@BaseClass base(Targetname, Parentname, Origin, Angles, RenderFields, Global, Shadow) = BaseTank
[
	spawnflags(flags) =
	[
		1 : "Active" : 0
		16: "Only Direct" : 0
		32: "Controllable" : 0
		64: "Damage Kick" : 0
	      1024: "NPC Controllable" : 0
              2048: "NPC Set Controller" : 0
	      4096: "Allow friendlies to hit player" : 0
	     32768: "Non-solid." : 0
	]

	control_volume(target_destination) : "Control Volume" : "" : "Name of a trigger the specifies the volume in which a player must be to control this tank."

//	 Mainly for use with 1009 team settings (game_team_master)
	master(string) : "(Team) Master" 

	yawrate(string) : "Yaw rate" : "30"
	yawrange(string) : "Yaw range" : "180"
	yawtolerance(string) : "Yaw tolerance" : "15"
	pitchrate(string) : "Pitch rate" : "0"
	pitchrange(string) : "Pitch range" : "0"
	pitchtolerance(string) : "Pitch tolerance" : "5"
	barrel(string) : "Barrel Length" : "0"
	barrely(string) : "Barrel Horizontal" : "0"
	barrelz(string) : "Barrel Vertical" : "0"
	spritesmoke(sprite) : "Smoke Sprite" : ""
	spriteflash(sprite) : "Flash Sprite" : ""
	spritescale(string) : "Sprite scale" : "1"
	firesound(sound) : "Firing Sound" : "Weapon_functank.Single"
	rotatestartsound(sound) : "Rotate Start Sound" : ""
	rotatesound(sound) : "Rotate Loop Sound" : ""
	rotatestopsound(sound) : "Rotate Stop Sound" : ""
	firerate(string) : "Rate of Fire" : "1"
	bullet_damage(string) : "Damage Per Bullet" : "0" : "If set to 0, it'll use the base weapon bullet's damage."
	bullet_damage_vs_player(string) : "Damage Per Bullet Vs Player" : "0" : "If set to 0, it'll use the Damage Per Bullet value."
	persistence(string) : "Firing persistence" : "1" : "(Seconds) How long to keep firing at last known position after lose sight of target"
	persistence2(string) : "Firing persistence2" : "0" : "(Seconds) After lost enemy and persistence time has passed, how long to occasionally fire at enemy's last known position"
	firespread(choices) : "Bullet accuracy" : 0 =
	[
		0: "Perfect Shot"
		1: "Small cone"
		2: "Medium cone"
		3: "Large cone"
		4: "Extra-large cone"
	]
	minRange(string) : "Minmum target range" : "0"
	maxRange(string) : "Maximum target range" : "0"
	_minlight(string) : "Minimum light level"

	gun_base_attach(string) : "Gun Base Attachment" : "" : "If Parent is specified, this is the attachment point on the parent to aim from."
	gun_barrel_attach(string) : "Gun Barrel Attachment" : "" : "If Parent is specified, this is the attachment point on the parent to fire from. If you specify this, you'll want to specify the Gun Base Attachment too."
	gun_yaw_pose_param(string) : "Gun Yaw Pose Param" : "" : "If Parent + the Gun Pitch Pose Param is specified, then the gun itself will be invisible and the func_tank will steer a gun on the parent using the pose parameters."
	gun_yaw_pose_center(float) : "Gun Yaw Pose Center" : "0" : "The center yaw pose parameter of the gun on the parent"
	gun_pitch_pose_param(string) : "Gun Pitch Pose Param" : "" : "If Parent + the Gun Yaw Pose Param is specified, then the gun itself will be invisible and the func_tank will steer a gun on the parent using the pose parameters."
	gun_pitch_pose_center(float) : "Gun Pitch Pose Center" : "0" : "The center pitch pose parameter of the gun on the parent"

	ammo_count(integer) : "Ammunition Count" : -1 : "Only applies to player use. -1 = unlimited ammo."

	LeadTarget(choices) : "Lead Target" : "No" =
	[
		0 : "No"
		1 : "Yes"
	]

	npc_man_point(target_destination) : "NPC Man Point" : "" : "Point where NPC must stand to man this 4:22 PM 7/26/2005."
	playergraceperiod(float) : "Post-NPC Attack Grace Period" : "0" : "If specified, NPC's manning this func tank won't fire at the player, after firing at a non-player, for this amount of time."
	ignoregraceupto(float) : "Ignore Grace Upto" : "768" : "The player grace period is ignored if the player's under this distance from the func_tank."
	playerlocktimebeforefire(float) : "Player Lock Time" : "0" : "The tank must have the player as a target for this amount of time before it's allowed to fire."

	effecthandling(choices) : "Effect Handling" : 0 =
	[
		0 : "Use Individual Settings."
		1 : "AR2"
	]

//	 Inputs
	input Activate(void) : "Turn the tank on"
	input Deactivate(void) : "Turn the tank off (go dormant)"
	input SetFireRate(string) : "How fast to fire (0 = don't fire)"
	input SetDamage(string) : "Set the Damage Per Bullet"
	input SetTargetPosition(string) : "World position that I should aim at"
	input SetTargetDir(vector) : "Direction to aim at."
	input SetTargetEntityName(string) : "Name of entity I should follow/attack"
	input SetTargetEntity(string) : "Entity I should follow/attack (output from other entity only)"
	input ClearTargetEntity(void) : "Clear the entity I should be attacking."
	input FindNPCToManTank(string) : "Find a nearby NPC to man this func_tank."
	input StartFindingNPCs(void) : "Start searching for NPCs to man this func_tank."
	input StopFindingNPCs(void) : "Stop searching for NPCs to man this func_tank."
	input ForceNPCOff(void) : "Force the NPC manning this func_tank (if any) to leave."
	input SetMaxRange(float) : "Set the max range of the func_tank."

//	 Outputs
	output OnFire(void) : "Fires when the tank fires its bullets"
	output OnAquireTarget(void) : "Fires when target is newly in range and can be shot"
	output OnLoseTarget(void) : "Fires when when target goes out of range"
	output OnAmmoDepleted(void) : "Fires when tank runs out of ammo"
	output OnGotController(void) : "Fires when an NPC starts to control this tank. Players do NOT fire this input."
	output OnLostController(void) : "Fires when the NPC controller of the tank stops controlling it. Players do NOT fire this input."
	output OnGotPlayerController(void) : "Fires when a Player starts to control this tank. NPCs do NOT fire this input."
	output OnLostPlayerController(void) : "Fires when the Player controller of the tank stops controlling it. NPCs do NOT fire this input."
	output OnReadyToFire(void) : "Fires once when the tank is done waiting to fire between rounds"
]


@SolidClass base(BaseTank) = func_tank : "Brush Gun Turret" 
[
	bullet(choices) : "Bullets" : 0 = 
	[
		0: "None"
		1: "Small"
		2: "Medium"
		3: "Large"
	]

	spawnflags(flags) =
	[
		8192: "Ignore range when making viewcone checks" : 0
		256 : "Aiming Assistance (Player Only)" : 0
	]
]


@SolidClass base(BaseTank) = func_tankpulselaser : "Brush Pulse Laser" 
[
	PulseSpeed(float) : "Pulse Speed" : 1000 : "How fast does pulse travel"
	PulseColor(color255) : "Pulse Color" : "255 0 0" : "Color of the pulse"
	PulseWidth(float) : "Pulse Width" : "20" : "Width of the pulse"
	PulseLife(float) : "Pulse Life" : 2 : "(Seconds)  How long the pulse lasts"
	PulseLag(float) : "Pulse Lag" : "0.05" : "(Seconds)  How far behind is pulse tail"
	PulseFireSound(sound)   : "Pulse Fire Sound" : "" : "Sound played when pulse fires"
]


@SolidClass base(BaseTank) = func_tanklaser : "Brush Laser Turret" 
[
	laserentity(target_destination) : "env_laser Entity"
]


@SolidClass base(BaseTank) = func_tankrocket : "Brush Rocket Turret"
[
	rocketspeed(float) : "Projectile speed" : 800 : "Speed the rocket will travel at."
]

@SolidClass base(BaseTank) = func_tankairboatgun : "Airboat Gun Turret"
[
	airboat_gun_model(target_destination) : "Name of a prop_dynamic which is the airboat gun model"
]

@SolidClass base(BaseTank) = func_tankapcrocket : "APC Rocket Turret"
[
	rocketspeed(float) : "Projectile speed" : 800 : "Speed the rocket will travel at."
	burstcount(integer) : "Burst shot count" : 10 : "Number of missiles to shoot in a burst"

	input DeathVolley(void) : "Fire a burst of rockets cause we're dying."
]


@SolidClass base(BaseTank) = func_tankmortar : "Brush Mortar Turret" 
[
	iMagnitude(Integer) : "Explosion Magnitude" : 100
	firedelay(string) : "Shell travel time" : 2 : "How long after the turret fires before the shell impacts"
	firestartsound(sound) : "Firing start sound" : "" : "Sound of the mortar firing"
	fireendsound(sound) : "Firing end sound" : "" 
	incomingsound(sound) : "Incoming Shell Sound" : "" : "Sound of the shell falling on the target"
	warningtime(float) : "Incoming warning time" : "1" : "How long before the shell impacts to play the warning sound"
	firevariance(float) : "Fire time variance" : "0" : "How much variability to add to fire rate (time +-)"

	input FireAtWill(void) : "Allow tank to fire next shot as soon as ready."
]

@SolidClass base(BaseTank) = func_tankphyscannister : "PhysCannister Turret"
[
	barrel_volume(target_destination) : "Barrel Volume" : "" : "Name of a trigger the specifies the volume in which cannisters must be placed."
]

//-------------------------------------------------------------------------
//
// Items
//
//-------------------------------------------------------------------------
@BaseClass color(0 0 200) base(Targetname, Angles, Shadow) = Item
[
	output OnPlayerTouch(void) : "Fires when the player touches this object"
]

@PointClass base(Item) studio("models/items/healthkit.mdl") = item_dynamic_resupply : "Dynamic item"
[
	spawnflags(Flags) =
	[
		1 : "Use Master's values" : 1
		2 : "Is Master" : 0
	]

	DesiredHealth(float) : "Desired Health Ratio" : "1" : "A ratio from 0 to 1. Attempt to fill the player up to this percentage of his max health."
	DesiredArmor(float) : "Desired Armor Ratio" : "0.3" : "A ratio from 0 to 1. Attempt to fill the player up to this percentage of his max armor."
	DesiredAmmoMagnum(float) : "Desired Magnum Ammo Ratio" : "0.5" : "A ratio from 0 to 1. Attempt to fill the player up to this percentage of his max ammo carrying capacity."

//	 Inputs
	input CalculateType(void) : "Force the dynamic resupply to calculate which item it should spawn."
	input BecomeMaster(void) : "Make this resupply the master resupply. All other resupplies set to Use Master's Values will now use this resupply's values."
]

@PointClass base(Item) studio("models/items/ammo/ammo_magbullets.mdl")= item_ammo_magnum : "Box of Magnum ammo" []
@PointClass base(Item) studio("models/items/ammo/ammo_assbullets.mdl")= item_ammo_ar : "Box of Assault Rifle Ammo" []
@PointClass base(Item) studio("models/items/ammo/ammo_shotshells.mdl")= item_ammo_buckshot : "Box of Buckshot" []
@PointClass base(Item) studio("models/items/ammo/ammo_magduag.mdl")= item_ammo_duag : "DUAG Ammo" []
@PointClass base(Item) studio("models/items/ammo/ammo_assgrenades.mdl")= item_ammo_ar_grenade : "Assault Rifle Grenade" []
@PointClass base(Item) studio("models/items/ammo/ammo_shotflak.mdl")= item_ammo_flak : "FLAK Ammo" []
@PointClass base(Item) studio("models/weapons/w_rocket_closed.mdl")= item_ammo_rocket : "Rocket" []

// Health items
@PointClass base(Item) studio("models/items/antigenvial/antigenvial.mdl") = item_healthvial : "Tiny Health (+10)" []
@PointClass base(Item) studio("models/items/antigen_mega/antigen_mega.mdl") = item_megahealth : "Mega Health (+100)" []

@PointClass base(Targetname, Angles) studio("models/items/ammocrate_rockets.mdl") = item_ammo_crate : "Ammo Crate"
[
	AmmoType(choices) : "Ammo Type" : 0 =
	[
		0 : "Grenades"
		1 : "DUAG"
	]

//	 Inputs
	input Kill(void) : "Remove the ammo crate"
	output OnUsed(void) : "Fires when +used by the player."
]

@PointClass base(BasePropPhysics, Targetname, Angles, DamageFilter) studio("models/items/item_item_crate.mdl") = item_item_crate : "Item Crate"
[
	CrateType(choices) : "Crate Contains" : 0 =
	[
		0 : "Contains specified item"
		1 : "Contains group item(s)"
	]

	ItemClass(pointentityclass) : "Item Type" : "item_dynamic_resupply" : "Class name of the entity to spawn when the crate is broken"
	ItemCount(integer) : "Item Count" : 1 : "Number of items to emit upon breakage"
	GroupItemHealth(integer) : "Group Item Health" : 0 : "Health (Set to 1 to turn on, 0 to turn off)"
	GroupItemPrimAmmo(integer) : "Group Item Primary Ammo" : 0 : "Primary Ammo (Set to 1 to turn on, 0 to turn off)"
	PrimAmmoType(choices) : "Primary Ammo Type" : "0" =
	[
		"0" : "Random"
		"1" : "Most need"
		"MAG" : "Magnum"
		"BUCK" : "Scattergun"
		"AR" : "Assault Rifle"
	]
	GroupItemSecAmmo(integer) : "Group Item Secondary Ammo" : 0 : "Secondary Ammo (Set to 1 to turn on, 0 to turn off)"
	SecAmmoType(choices) : "Secondary Ammo Type" : "0" =
	[
		"0" : "Random"
		"1" : "Most need"
		"DUAG" : "Magnum"
		"FLAK" : "Scattergun"
		"ARNADE" : "Assault Rifle"
	]
	GroupItemGren(integer) : "Group Item Grenades" : 0 : "Grenades (Set to 1 to turn on, 0 to turn off)"

//	 Inputs
	input Kill(void) : "Remove the item crate"
	input Break(void) : "Breaks the breakable."
	input SetHealth(integer) : "Sets a new value for health. If the breakable's health reaches zero it will break."
	input AddHealth(integer) : "Adds health to the breakable. If the breakable's health reaches zero it will break."
	input RemoveHealth(integer) : "Removes health from the breakable. If the breakable's health reaches zero it will break."
	
//	 Outputs
	output OnBreak(void) : "Fires when broken."
	output OnHealthChanged(float) : "Fires when the health of this breakable changes, passing the new value of health as a percentage of max health, from [0..1]."
]

@PointClass base(Targetname,Angles) studio("models/items/antigen/antigen_dispenser.mdl") = item_antigen_dispenser : "Antigen Dispenser" 
[
	disabled(integer) : "Disabled" : 0
	antigen(float) : "Antigen" : 100 : "Percentage full, if 0 then this dispenser can be loaded with an antigen container"
	output OnCanisterInserted(void) : "Fires when an antigen canister is put into the dispenser."
	output OnCanisterEjected(void) : "Fires when an antigen canister is ejected from the dispenser."
]

@PointClass base(Targetname, Angles) studio( "models/items/car_battery01.mdl" ) = item_dna_scanner : "DNA scanner"
[
//	 Outputs
    output OnScan(void) : "Fired when the scanner successfully scans a victim."
]

@PointClass base(Targetname, Angles) studio( "models/props_combine/suit_charger001.mdl" ) = item_suitcharger : "Battery recharger"
[
//	 dmdelay(integer) : "Deathmatch recharge delay" : 0
	_minlight(string) : "Minimum light level"

	spawnflags(flags) =
	[
		8192  : "Citadel recharger" : 0
		16384 : "Kleiner's recharger" : 0
	]

//	 Inputs
	input Recharge(void) : "Recharge to full"

//	 Outputs
	output OutRemainingCharge(float) : "Remaining Charge."
	output OnHalfEmpty(void) : "Half-Empty"
	output OnEmpty(void) : "Empty"
	output OnFull(void) : "Recharged to full."
	output OnPlayerUse(void) : "Fired when the player +USEs the charger."
]

//-------------------------------------------------------------------------
//
// Weapons
//
//-------------------------------------------------------------------------
@BaseClass color(0 0 200) base(Targetname, Angles) = Weapon
[
	spawnflags(Flags) =
	[
		1 : "Start constrained" : 0
	]
	
	PrimaryAmmoCount(integer) : "Primary Ammo Count" : : "Primary Ammo Count"
	SecondaryAmmoCount(integer) : "Secondary Ammo Count" : : "Secondary Ammo Count"
	
	
	output OnPlayerUse(void) : "Fires when the player +uses this weapon"
	output OnPlayerPickup(void) : "Fires when the player picks up this weapon"
	output OnNPCPickup(void) : "Fires when an NPC picks up this weapon"
]

@SolidClass base(Trigger) = trigger_rpgfire :
	"A volumetric trigger that triggers whenever an RPG is fired within it."
[
//	 Outputs
	output OnTrigger(void) : "Fires while the trigger is activated"
]

@SolidClass base(Trigger) = trigger_vphysics_motion :
	"A volumetric trigger that affects the motion of vphysics objects that touch it."
[
	spawnflags(Flags) =
	[
		4096 : "Can move (through hierarchical attachment)" : 0
	]

	StartDisabled(choices) : "Start Disabled" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]
	filtername(filterclass) : "Filter Name" : : "Filter to use to see if activator triggers me. See filter_activator_name for more explanation."
	
	SetGravityScale(float) : "Scale gravity of objects in the field." : "1.0"
	input SetGravityScale(float) : "Scale gravity of objects in the field."

	SetAdditionalAirDensity(float) : "Additional air density for drag" : "0"
	input SetAdditionalAirDensity(float) : "Additional air density for drag"

	SetVelocityLimit(float) : "Max velocity in field (0 disables)" : "0.0"
	input SetVelocityLimit(float) : "Max velocity in field."

	SetVelocityLimitDelta(float) : "Max amount to reduce velocity per second when it exceeds the velocity limit (0 disables)" : "0.0"
	input SetVelocityLimitDelta(float) : "Max amount to reduce velocity per second"

	input SetVelocityLimitTime(string) : "Accepts two arguments: the first is the new velocity limit, the second is the time it takes to ramp to that value"

	SetVelocityScale(float) : "Velocity scale/drag" : "1.0"
	input SetVelocityScale(float) : "Velocity scale/drag"

	SetAngVelocityLimit(float) : "Max angular velocity in field (degrees/s, 0 disables)" : "0.0"
	input SetAngVelocityLimit(float) : "Max angular velocity in field."

	SetAngVelocityScale(float) : "Angular Velocity scale/drag" : "1.0"
	input SetAngVelocityScale(float) : "Angular Velocity scale/drag"

	SetLinearForce(float) : "Linear force (0 disables)" : "0.0"
	input SetLinearForce(float) : "Linear force (0 disables)"

	SetLinearForceAngles(angle) : "Direction of linear force (Pitch Yaw Roll (Y Z X))" : "0 0 0"
//	input SetLinearForceAngles(angle) : "Direction of linear force (Pitch Yaw Roll (Y Z X))"

	ParticleTrailMaterial(string) : "Particle Trail Material" : : "Name of a material to use for the particle trail, no name means no particle trail"
	ParticleTrailLifetime(float) : "Particle Trail Lifetime" : 4 : "Lifetime of the particles to emit"
	ParticleTrailStartSize(float) : "Particle Trail Starting Sprite Size" : 2 : "Starting size of the sprite to emit"
	ParticleTrailEndSize(float) : "Particle Trail Ending Sprite Size" : 3 : "Ending size of the sprite to emit"

//	 Inputs
	input	Enable(void) : "Enable the trigger."
	input	Disable(void): "Disable the trigger."
	input	Toggle(void) : "Toggle enable/disable."
]

@PointClass base(Targetname) size( 16 16 16) sphere() color( 255 255 0 ) = point_bugbait : "Bugbait sensor point"
[
	Enabled(choices) : "Start Enabled" : 1 =
	[
		0 : "No"
		1 : "Yes"
	]

	spawnflags(Flags) =
	[
		1: "Do not call antlions to position" : 0
		2: "Don't activate on thrown bugbait splashes" : 0
		4: "Don't activate on squeezed bugbait" : 0
	]

	radius(integer) : "Sensor Radius" : 512

//	 Inputs
	input	Enable(void) : "Enable the sensor."
	input	Disable(void): "Disable the sensor."
	input	Toggle(void) : "Toggle the sensor."

//	 Outputs
	output OnBaited(void) : "Fires when bugbait lands within a radius of the sensor"
]

@PointClass base(Weapon) = weapon_brickbat : "Brickbat"
[
	BrickbatType(choices) : "BrickbatType" : "Rock" =
	[
		0 : "Rock"
		1 : "Beer Bottle"
		2 : "Headcrab"
		3 : "Cremator Head"
	]
]


@PointClass base(Targetname, Angles) size(16 16 16) line(255 255 255, targetname, target) color(247 181 82) = path_corner : "Generic path point"
[
	spawnflags(Flags) =
	[
		1: "Wait for retrigger" : 0
		2: "Teleport to THIS path_corner" : 0
	]
	target(target_destination) : "Next stop target"
	wait(integer) : "Wait here (secs)" : 0
	speed(integer) : "New Train Speed" : 0
	yaw_speed(integer) : "New Train rot. Speed" : 0

//	 Inputs 
	input SetNextPathCorner(string) : "Sets next pathcorner"

//	 Outputs
	output OnPass(void) : "Fires when a path follower passes this point"
]

@PointClass base(Targetname) size(16 16 16) color(255 0 0) = path_corner_crash : "Helicopter Crash Path"
[
	target(target_destination) : "Next stop target"
]


//-------------------------------------------------------------------------
//
// Player effects
//
//-------------------------------------------------------------------------

@PointClass base(Targetname) size(-16 -16 -16, 16 16 16) = player_loadsaved : "Load Auto-Saved game" 
[
	duration(string) : "Fade Duration (seconds)" : "2"
	holdtime(string) : "Hold Fade (seconds)" : "0"
	renderamt(integer) : "Fade Alpha" : 255
	rendercolor(color255) : "Fade Color (R G B)" : "0 0 0"
	loadtime(string) : "Reload delay" : "0"

//	 Inputs
	input Reload(void) : "Ends this game and reloads"
]


@PointClass base(Targetname) size(-16 -16 -16, 16 16 16) = player_weaponstrip : "Strips player's weapons"
[
//	 Inputs
	input Strip(void) : "Strip player's weapons"
	input StripWeaponsAndSuit(void) : "Strip player's weapons and his suit"
]

@PointClass base(Targetname) size(-16 -16 -16, 16 16 16) = player_speedmod: "Speeds up or slows down player velocity over time (slow mo/fast forward)"
[
//	 Inputs
	input ModifySpeed(float) : "Modifies player speed by X ammount."
]



//-------------------------------------------------------------------------
//
// Logic Entities
//
//-------------------------------------------------------------------------
@PointClass color(0 0 255) base(Targetname) iconsprite("editor/choreo_scene.vmt") = logic_choreographed_scene :
	"Manages a choreographed scene of one or more actors."

[
//	 Keys
	SceneFile(scene) : "Scene file"

//	 Links
	target1(target_destination) : "Target 1"
	target2(target_destination) : "Target 2"
	target3(target_destination) : "Target 3"
	target4(target_destination) : "Target 4"
	target5(target_destination) : "Target 5"
	target6(target_destination) : "Target 6"
	target7(target_destination) : "Target 7"
	target8(target_destination) : "Target 8"

	busyactor(choices) : "If an Actor is talking..." : 0 : "What to do if an actor this scene needs is already talking when this scene is told to start." =
	[
		0: "Default"
		1: "Wait for actor to finish"
	]

//	 Inputs
	input Start(void) : "Starts playback of the scene file"
	input Pause(void) : "Pauses playback of the scene file"
	input Resume(void) : "Resumes playback of the scene if it has been paused"
	input Cancel(void) : "Cancels playback of the scene"

	input InterjectResponse(string) : "Finds an actor who can respond to the specified concept string while the scene continues playing"

	input StopWaitingForActor(void) : "Stop waiting on an actor to stop talking."

//	 Inputs
	output OnStart(void) : "The scene has started"
	output OnCompletion(void) : "The scene has completed"
	output OnCanceled(void) : "The scene has been canceled"
	output OnTrigger1(void) : "Scene trigger 1"
	output OnTrigger2(void) : "Scene trigger 2"
	output OnTrigger3(void) : "Scene trigger 3"
	output OnTrigger4(void) : "Scene trigger 4"
	output OnTrigger5(void) : "Scene trigger 5"
	output OnTrigger6(void) : "Scene trigger 6"
	output OnTrigger7(void) : "Scene trigger 7"
	output OnTrigger8(void) : "Scene trigger 8"
] 

@PointClass base(Targetname) iconsprite("editor/logic_multicompare.vmt") = logic_menulistener :
	"Allows maps to respond to player inputs in the main menu"
[
	// Outputs
	output resumeGamePressed(void) : "Fires if the user clicks on resume game"
	output newGamePressed(void) : "Fires if the user clicks on new game"
	output optionsPressed(void) : "Fires if the user clicks on options"
	output loadGamePressed(void) : "Fires if the user clicks on load game"
	output saveGamePressed(void) : "Fires if the user clicks on save game"
	output statsPressed(void) : "Fires if the user clicks on Stats"
	output friendsPressed(void) : "Fires if the user clicks on friends"
	output quitPressed(void) : "Fires if the user clicks on quit"

	output resumeGameMousedOver(void) : "Fires if the user clicks on resume game"
	output newGameMousedOver(void) : "Fires if the user clicks on new game"
	output optionsMousedOver(void) : "Fires if the user clicks on options"
	output loadGameMousedOver(void) : "Fires if the user clicks on load game"
	output saveGameMousedOver(void) : "Fires if the user clicks on save game"
	output statsMousedOver(void) : "Fires if the user clicks on Stats"
	output friendsMousedOver(void) : "Fires if the user clicks on friends"
	output quitMousedOver(void) : "Fires if the user clicks on quit"
]

@PointClass base(Targetname, Parentname) iconsprite("editor/ai_sound.vmt") = ai_sound :
	"This entity makes sounds or smells that can be sensed by NPCs, butnot by the player. This can be used " +
	"to cause reactions in nearby NPCs.\n\n" +
	"Sound Types\n" +
	"  Combat: Will cause most NPCs to become alert\n" +
	"  World: Will cause most NPCs to become alert\n" +
	"  Danger: Will cause most NPCs to move away from the position of the sound\n" +
	"  Bullet Impact: \n" +
	"  Carcass: \n" +
	"  Meat: \n" +
	"  Garbage: \n" +
	"  Thumper: causes antlions to run away briefly\n" +
	"  Readiness: (Low, Medium, High) Causes player companions that can hear this sound to change readiness\n"
[
	input InsertSound(Integer) : "Insert a sound in the AI sound list"

	soundtype(choices) : "Sound Type" : 0 : "The type of sound or smell will determine the reaction of NPCs that sense it." =
	[
		1: "Combat"
		2: "World"
	//	4: "Player (Don't use)"
		8: "Danger"
		16: "Bullet Impact"
		32: "Carcass"
		64: "Meat"
		128: "Garbage"
		256: "Thumper"
		16384 : "Readiness - Low"
		32768 : "Readiness - Medium"
		65536 : "Readiness - High"
	]

	locationproxy(target_destination) : "Location Proxy" : "" : "The name of an entity to use as a proxy to determine the location at which to make the sound. If you specify an entity here, the sound will be made at that entity's location (!player included)" 
]

@PointClass size( -4 -4 -4, 4 4 4 ) base(Targetname, Parentname) = env_rotorwash : "Rotorwash Effect"
[
	spawnflags(Flags) =
	[
		1 : "Ignore solid" : 0
	]

	input DoEffect(Void) : "Make a rotor puff"
]

@PointClass size( -4 -4 -4, 4 4 4 ) base(Targetname, Parentname) studio("models/props_combine/combine_mine01.mdl") = combine_mine : "Combine Land Mine"
[
	bounce(choices) : "Bounce" : 1 : "Whether the mine should bounce up in the air before exploding." =
	[
		0: "No"
		1: "Yes"
	]

	LockSilently(choices) : "Lock Silently" : 1 : "If yes, mine plays no sound when clamps close" =
	[
		0: "No"
		1: "Yes"
	]

	StartDisarmed(choices) : "Start Disarmed" : 0 : "If yes, mine begins dormant." =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input Disarm(void) : "Disarm this mine (open hooks and shut off) if not placed by player."

//	 Outputs
	output OnPulledUp(void) : "Fires when this mine is uprooted with physgun"
]

@PointClass size( -4 -4 -4, 4 4 4 ) base(Targetname, Parentname) = env_ar2explosion :
	"AR2 explosion visual effect. Big, volume-filling brown cloud. Does not cause damage or emit sound."
[
	input Explode(Void) : "Make the explosion effect."
	material(material) : "Particle Material" : "particle/particle_noisesphere" : "The material to use for each particle in the explosion."
]

@PointClass size( -4 -4 -4, 4 4 4 ) base(Targetname) = env_starfield : "Starfield effect" 
[
	input TurnOn(void) : "Turn on"
	input TurnOff(void) : "Turn off"
	input SetDensity(float) : "Set the density of the starfield. It's a multiplier, so 1 is the default."
]

@PointClass size( -4 -4 -4, 4 4 4 ) base(Targetname, Parentname, Angles) = env_flare : "Flare"
[
	scale(float) : "Scale" : 1
	duration(float) : "Duration" : 30
	
	spawnflags(Flags) =
	[
		1 : "No DLight" : 0
		2 : "No Smoke" : 0
		4 : "Infinite" : 0
		8 : "Start off" : 0
	]

	input Start(float) : "Start"
	input Die(float) : "Die"
	input Launch(float) : "Launch the flare forward with the specified speed."
]


@PointClass base(Targetname, Parentname, Angles) = env_muzzleflash : "Muzzle Flash" 
[
	parentattachment(string) : "Parent Attachment" : "" : "The name of an attachment on the parent to hierarchically attach to."
	scale(float) : "Scale" : "1" : "Size of the muzzle flash."
	
	input Fire(void) : "Fires the effect once."
]


@PointClass base(Targetname, Parentname) size(-4 -4 -4, 4 4 4) color(0 180 0) = env_terrainmorph : 
	"Morphs terrain by pulling vertices along a normal.\n\n" +
	"Place this entity the desired distance from a terrain surface and set ANGLES " +
	"to the normal along which you want to pull the surface's vertices. If you set the INSTANT spawnflag, " +
	"the morph will take place instantly instead of over time.\n"
[
	startradius( integer ) : "Start Radius" : 500 : "Radius of the effect when morphing begins. Only this value is used" +
													"if the effect is flagged to occur instantly."
	goalradius( integer ) : "Goal Radius" : 100 : "Radius of the effect at the end of morphing. The radius of this effect will change from "+
												  "Start Radius to Goal Radius over the duration of this effect. This value is ignored if the effect is flagged to occur instantly."

	duration( integer ) : "Duration" : 3 : "The morph will take place over this period of time (seconds). Ignored if flagged to occur instantly"

	fraction( integer ) : "Displacement Fraction" : 1 : "If set to 1, the terrain surface will be pulled exactly to this entity's position." +
														" If set to 0.5, the surface will be pulled exactly half way to this entity's position. " +
														"If set to 2, the surface will be pulled to an imaginary point twice as far away as this entity. " +
														"(Any Displacement Fraction greater than 1.0 will result in clipping. The surface cannot be pulled beyond " +
														"This entity's position and any vertices attemping will clip to this entity's position. You may use this feature to create mesas.)"

//	 Inputs
	input BeginMorph(void) : "Begin Morph"

	spawnflags(flags) =
	[
		1: "Instant" : 0 
	]
]


//-------------------------------------------------------------------------
//
// Camera/monitor entities
//
//-------------------------------------------------------------------------
@PointClass base(Parentname, Angles) studioprop("models/editor/camera.mdl") = point_camera : "Camera"
[
	spawnflags(Flags) =
	[
		1 : "Start Off" : 0 
	]

	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	FOV(float) : "FOV" : 90 : "Field of view in degrees"
//	resolution(float) : "resolution" : 256 : "width/height of the render target for the camera"
	UseScreenAspectRatio(choices) : "Screen Aspect Ratio" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]	
	fogEnable(choices) : "Fog Enable" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]	
	fogColor(color255) : "Fog Color" : "0 0 0"
	fogStart(float) : "Fog Start" : 2048 : "The near fog plane."
	fogEnd(float) : "Fog End" : 4096 : "The far fog/clipping plane."
	isHUDCamera(choices) : "HUD Camera" : 0 : "Whether the camera's view is displayed on the HUD" =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
	input ChangeFOV(string) : "Changes camera's FOV over time"
	input SetOnAndTurnOthersOff(void) : "Turn the camera on, and turn all other cameras off."
	input SetOn(void) : "Turn the camera on."
	input SetOff(void) : "Turn the camera off."
]

@SolidClass base(func_brush) = func_monitor :
	"A monitor that renders the view from a given point_camera entity."
[
	target(target_destination) : "Camera name"
	
//	 Inputs
	input Toggle(void) : "Toggle - If on, turn off, if off, turn on."
	input Enable(void) : "Enable."
	input Disable(void) : "Disable."
	input SetCamera(string) : "Sets the camera to use for this monitor. Takes the name of a point_camera entity in the map."
]


//-------------------------------------------------------------------------
//
// Vehicles.
//
//-------------------------------------------------------------------------
@BaseClass base(Targetname, Origin, Global, prop_static_base) = BaseVehicle
[
	vehiclescript(string) : "Vehicle Script File" : "scripts/vehicles/jeep_test.txt"
	actionScale(float) : "Scale of action input / framerate" : "1"

//	 Inputs
	input Action(float) : "Set the speed of the action animation"

	input TurnOn(void) : "Turn on: Start engine & enable throttle"
	input TurnOff(void) : "Turn off: Stop engine, disable throttle, engage brakes."

	input Lock(void) : "Prevent the player from entering or exiting the vehicle."
	input Unlock(void) : "Re-allow the player to enter or exit the vehicle."
	
	input SetVehicleVolume(float) : "Set the volume for vehicle sounds. (0.0 - 1.0)"
	input FadeSoundOut(float) : "Fade the volume for vehicle sounds out. Param is time of fade out."
	input FadeSoundIn(float) : "Fade the volume for vehicle sounds in. Param is time of fade in."
]


@BaseClass base(BaseVehicle) = BaseDriveableVehicle
[
	VehicleLocked(choices) : "Start locked" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]	

//	 Outputs
	output PlayerOn(void) : "Player entered the vehicle"
	output PlayerOff(void) : "Player exited the vehicle"
	
	output PressedAttack(void) : "Player Pressed attack key"
	output PressedAttack2(void) : "Player Pressed attack2 key"

	output AttackAxis(string) : "State of attack button [0,1]"
	output Attack2Axis(string) : "State of attack2 button [0,1]"
	
//	 Inputs
	input HandBrakeOn(void) : "Turns the handbrake on"
	input HandBrakeOff(void): "Releases the handbrake"
]

@PointClass base(BaseVehicle) studioprop() = prop_vehicle :
	"Studiomodel vehicle that can be driven via inputs."
[
//	 Inputs
	input Steer(float) : "Steer the vehicle +/-1"
	input Throttle(float) : "Throttle +/-1"
]


@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_driveable :
	"Generic driveable studiomodel vehicle."
[
]

@PointClass base(Targetname, Angles) studio() = point_apc_controller : "APC Controller"
[
	spawnflags(flags) =
	[
		1 : "Active" : 0
	]

	yawrate(string) : "Yaw rate" : "30"
	yawtolerance(string) : "Yaw tolerance" : "15"
	pitchrate(string) : "Pitch rate" : "0"
	pitchtolerance(string) : "Pitch tolerance" : "20"
	rotatestartsound(sound) : "Rotate Start Sound" : ""
	rotatesound(sound) : "Rotate Loop Sound" : ""
	rotatestopsound(sound) : "Rotate Stop Sound" : ""
	minRange(string) : "Minmum target range" : "0"
	maxRange(string) : "Maximum target range" : "0"
	targetentityname(string) : "Name of entity I should follow/attack" : ""

//	 Inputs
	input Activate(void) : "Turn the APC rockets on"
	input Deactivate(void) : "Turn the APC rockets off (go dormant)"

//	 Outputs
	output OnFireAtTarget(void) : "Fires when a valid target is found and the APC should shoot rockets"
]

@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_apc :
	"APC with mounted guns, can only be driven by a vehicle driver or a npc_apcdriver."
[
	missilehint(target_destination) : "Missile Hint Target" : "" : "Name of one or more info_apc_missile_hint entities to use to determine what to hit."
	input FireMissileAt(target_destination) : "A target to fire a missile at"
	input Destroy(void) : "Causes the APC to blow up."
	output OnFiredMissile(void) : "Fired when the APC shoots a missile."
	output OnDeath(void) : "Fired when the APC is killed."
]

@SolidClass base(Targetname, Origin, Angles, EnableDisable) = info_apc_missile_hint :
	"Something that helps APC missiles guide. If the missile can hit the associated target entity"+
	"between the time it takes the current enemy to enter + leave the hint, then the missile will guide to the entity."
[
	target(target_destination) : "Target Entity" : "" : "The entity that the missile will guide towards if the conditions are met."
]

@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_jeep :
	"Driveable studiomodel jeep."
[
	input StartRemoveTauCannon(void) : "Start the tau removal sequence."
	input FinishRemoveTauCannon(void) : "Finish the tau removal sequence."
]

@PointClass base(BaseDriveableVehicle) studioprop() = vehicle_viewcontroller : 
	"Vehicle hack to control player view"
[
	input ForcePlayerIn(string) : "Force the player into the vehicle. The animation to use can be specified in the parameter. Without a parameter, the player just teleports."
	input ForcePlayerOut(void) : "Force the player out of the vehicle."
]

@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_airboat :
	"Driveable studiomodel airboat."
[
	model(studio) : "World model" : "models/airboat.mdl"
	vehiclescript(string) : "Vehicle Script File" : "scripts/vehicles/airboat.txt"
	EnableGun(choices) : "Has Gun" : 0 : "Whether the airboat's gun is enabled or disabled." =
	[
		0 : "No"
		1 : "Yes"
	]
	input EnableGun(bool) : "Enables or disables the airboat gun and associated crosshair."
	input InputStartRotorWashForces(void) : "The airboat will start to be blown around by the helicopter rotor wash."
	input InputStopRotorWashForces(void) : "The airboat will no longer be blown around by the helicopter rotor wash."
]

@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_cannon :
	"Driveable studiomodel cannon."
[

]

@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_crane :
	"Driveable studiomodel crane."
[
	magnetname(target_destination) : "Magnet entity" : ""

	input ForcePlayerIn(void) : "Force the player to get into the crane. Only works in singleplayer."
]

@PointClass base(BaseDriveableVehicle, Parentname) studioprop() = prop_vehicle_prisoner_pod :
	"Combine prisoner pod that the player can ride in."
[
	model(studio) : "World model" : "models/vehicles/prisoner_pod.mdl"
	vehiclescript(string) : "Vehicle Script File" : "scripts/vehicles/prisoner_pod.txt"
	
	input Open(void) : "Plays the pod's open animation and unlocks the pod for entry or exit."
	input Close(void) : "Plays the pod's close animation and locks the pod for entry or exit."
	input EnterVehicle(void) : "Forces the activator (or player) into the pod."
	input EnterVehicleImmediate(void) : "Forces the activator (or player) into the pod without enter/exit animations."
	input ExitVehicle(void) : "Boots the prisoner out of the pod."
	
	output OnOpen(void) : "Fired when the pod is open enough to enter."
	output OnClose(void) : "Fired when the pod too closed to enter."
]


@PointClass base(Targetname) = phys_constraintsystem : "Used to manage a group of interacting constraints and keep them stable."
[
]

@PointClass base(BaseSpeaker) iconsprite("editor/ambient_generic.vmt") = env_speaker : "Announcement Speaker"
[
]

//-------------------------------------------------------------------------
// Script entities
//-------------------------------------------------------------------------

@PointClass base(Angles,Targetname,Parentname) = script_tauremoval : "Script: Custom entity used to handle the tau removal sequence in coast. (unused)"
[
	vortigaunt(target_destination) : "Vortigaunt to use"

//	 Inputs
	input StartScript(void) : "Start the script."
	input RemoveTau(void) : "Start removing the Tau cannon now."
]

@PointClass base(Targetname) = script_intro : "Script: Custom entity used to handle the intro sequence."
[
//	 Inputs
	input Activate(void) : "Take control of the player's view and start blending the two scenes."
	input Deactivate(void) : "Stop controlling the view."
	input SetCameraViewEntity(string) : "Set the viewpoint to blend with the player's viewpoint."
	input SetBlendMode(integer) : "Set the blending mode to use."
	input SetFOV(integer) : "Set the fov for the second camera."
	input SetNextFOV(integer) : "Set the FOV to blend to over time. Follow this with a SetFOVBlendTime input to start the fov blend."
	input SetFOVBlendTime(float) : "Set the amount of time it should take to blend to the next fov target, and start blending."
	input SetNextBlendMode(integer) : "Set the blending mode to blend to over time. Follow this with a SetNextBlendTime input to start the mode blend."
	input SetNextBlendTime(float) : "Set the amount of time it should take to blend to the next mode, and start blending."
	input FadeTo(string) : "Fade to a specific alpha amount of an amount of time. Parameters: <alpha> <duration>"
	input SetFadeColor(string) : "Set the fade color. Parameters: <Red> <Green> <Blue>"
]

//-------------------------------------------------------------------------
//
// Special effects
//
//-------------------------------------------------------------------------

@PointClass base(Angles,Targetname,Parentname) = env_citadel_energy_core : "Special effect for the energy cores in citadel."
[
	spawnflags(Flags) = 
	[
		1 : "No small particles" : 0
		2 : "Start on" : 0
	]

	scale(float) : "Scale" : 1 : "Scale of the effect.  1 is the default size, 2 is twice that, etc."

//	 Inputs
	input StartCharge(float) : "Start charging the core over specified number of seconds."
	input StartDischarge(void) : "Start discharging the core over specified number of seconds."
	input Stop(float) : "Stops the effect at any point."
]

@PointClass base(Angles,Targetname,Parentname) size(-4 -4 -4, 4 4 4) color(0 0 255) line( 0 0 255, targetname, EndTargetName) = env_alyxemp : "Special effect for the Alyx's EMP device."
[
	Type(choices) : "EMP Type" : 0 =
	[
		0 : "Small"
		1 : "Large"
	]	

	EndTargetName(target_destination) : "Target Entity" : "" : "Entity to use as a target endpoint."

//	 Inputs
	input StartCharge(float) : "Start charging the effect over specified number of seconds."
	input StartDischarge(void) : "Start discharging the effect over specified number of seconds."
	input Stop(float) : "Stops the effect at any point."
	input SetTargetEnt(string) : "Sets the target entity for the effect."
]

//-------------------------------------------------------------------------
// Countdown timer for the teleporter at the end of the game
//-------------------------------------------------------------------------

@PointClass base(Targetname) iconsprite("editor/info_target.vmt")  = info_teleporter_countdown : "Countdown timer for the teleporter. The status of the teleporter will appear on vgui_screen entities whose panel is 'teleport_countdown_screen'." 
[
//	 Inputs
	input StartCountdown(float) : "Starts the teleporter countdown. Requires an argument which is the number of seconds for the countdown."
	input StopCountdown(void) : "Stops the countdown permanently"
	input Disable(void) : "Pauses the countdown due to a temporary malfunction. A warning sign will appear on the linked vgui screens."
	input Enable(void) : "Restarts the countdown since the malfunction is finished."
]

//-------------------------------------------------------------------------
//
// NPCs
//
//-------------------------------------------------------------------------

@PointClass base(Targetname) studio("models/weapons/grenades/frag_grenade.mdl") = npc_grenade_frag : "Frag Grenade"
[
	input SetTimer(float) : "Starts the grenade timer"
]

@PointClass base(Targetname) studio("models/weapons/grenades/frag_grenade.mdl") = npc_grenade_flash : "Flashbang"
[
	input SetTimer(float) : "Starts the grenade timer"
]

@BaseClass base(BaseNPC) = BotBase
[
    ShouldInspect(choices) : "Should inspect" : 1 =
	[
		0 : "No"
		1 : "Yes"
	]

	OnlyInspectPlayers(choices) : "Only Inspect Players" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	NeverInspectPlayers(choices) : "Never Inspect Players" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

//	 Inputs
    input InputSetFlightSpeed(integer) : "Sets the flight speed of the scanner"
	input InputShouldInspect(integer) : "Set whether should inspect or not"
	input SetFollowTarget(string) : "Set target to follow until told otherwise"
	input ClearFollowTarget(void) : "Stop following our target"
	input SetDistanceOverride(float) : "Override the distance the scanner will attempt to keep between inspection targets and itself"

	input DeployMine(void) : "Drop landmine (if carrying one)"
	input EquipMine(void) : "Equip with landmine"
]

@NPCClass base(BotBase) studio("models/combine_scanner.mdl") = npc_adbot : "Ad Bot"
[
]

@NPCClass base(BotBase) studio("models/characters/SecurityDrone_01/securitydrone_01.mdl") = npc_securitybot : "Security Bot"
[
]

@NPCClass base(BaseNPC,Parentname,Studiomodel) studio("models/characters/DockWorkers/dockworker01.mdl") = npc_civilian : "Civilian"
[
	heads(integer) : "Heads" : 0 : "Some models have different heads.  Set this to a number other than 0 to use that head instead of the default or -1 for a random head."
	
	spawnflags(Flags) =
	[
    131072 : "Don't use Speech Semaphore" : 0
		1048576 : "Use RenderBox in ActBusies" : 0
		2097152 : "One hit kill" : 0
	]

	expressiontype(choices) : "Expression Type" : "Random" =
	[
		0 : "Random"
		1 : "Scared"
		2 : "Normal"
		3 : "Angry"
	]

	ExpressionOverride(string) : "Facial expression override"

	notifynavfailblocked(choices) : "Fire output when Nav is blocked?" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]
	
	IgnorePush(float) : "Ignore Player Push" : 0 : "Should I ignore the player pushing me?"
	ShouldPatrol(integer) : "Enable Patrolling" : 0 : "Should I patrol when idle?"

//	 Inputs
	input IgnorePlayerPush(bool) : "Toggles whether or not I will ignore the player pushing me"
	input StartPatrolling(void) : "Enables patrolling when idle"
	input StopPatrolling(void) : "Disable patrolling when idel"

//	 Outputs
	output OnPlayerUse(void) : "Fires when a player +USEs the civilian"
]

@NPCClass base(npc_civilian) studio("models/characters/U4LabTechs/u4labtech_01.mdl") = npc_druglab_worker : "U4 druglab worker"
[
]

// @NPCClass base(BaseNPC,Parentname) studio("models/characters/HardcorpsGrunt/HardcorpsGrunt.mdl") = npc_hardcorps_grunt : "Hardcorps Grunt"
// [
// 
// 	spawnflags(Flags) =
// 	[
// 		65536 : "Follow player on spawn" : 0
// 		131072 : "Medic" : 0
// 		262144 : "Random Head" : 1
// 		524288 : "Ammo Resupplier" : 0
// 		1048576 : "Not Commandable" : 0
// 		2097152 : "Don't use Speech Semaphore" : 0
// 		4194304 : "Random male head" : 0
// 		8388608 : "Random female head" : 0
// 		16777216 : "Use RenderBox in ActBusies" : 0
// 	]
// 	
// 	NumGrenades(choices) : "Number of Grenades" : "5" =
// 	[
// 		"0" : "None"
// 		"1" : "1"
// 		"2" : "2"
// 		"3" : "3"
// 		"4" : "4"
// 		"5" : "5"
// 		"999999" : "Unlimited"
// 	]
// 
//     additionalequipment(choices) : "Weapons" : "weapon_assault_rifle" =
// 	[
//	"weapon_scattergun" : "Scatter Gun"
//		"weapon_assault_rifle" : "Assault Rifle"
//		"weapon_npc_pistol" : "Pistol"
//	]
//	
//	ammosupply(choices) : "Ammo to Resupply (if spawnflag set)" : "SMG1" =
//	[
//		"Pistol" : "Pistol"
//		"SMG1" : "SMG1"
//		"SMG1_Grenade" : "SMG1 Grenade"
//		"AR2" : "AR2"
//		"Buckshot" : "Shotgun"
//		"RPG_Round" : "RPG"
//		"Grenade" : "Grenade"
//		"XBowBolt" : "Crossbow Bolt"
//	]
//	ammoamount(integer) : "Amount of ammo to give" : 1
//
//	citizentype(choices) : "Type" : "Default" =
//	[
//		0 : "Default"	 
//		1 : "Downtrodden"
//		2 : "Refugee"
//		3 : "Rebel"
//		4 : "Unique"
//	]
//
//	expressiontype(choices) : "Expression Type" : "Random" =
//	[
//		0 : "Random"
//		1 : "Scared"
//		2 : "Normal"
//		3 : "Angry"
//	]
//
//	//!!!BUGBUG - don't ship with these names
//	//!!!FIXME - don't ship with these names
//	model(choices) : "Model" : "models/humans/group01/male_01.mdl" =
//	[
//		"models/humans/group01/male_01.mdl" : "Male 1"
//		"models/humans/group01/male_02.mdl" : "Male 2"
//		"models/humans/group01/male_03.mdl" : "Male 3"
//		"models/humans/group01/male_07.mdl" : "Male 4"
//		"models/humans/group01/male_08.mdl" : "Male 5"
//		"models/humans/group01/male_09.mdl" : "Male 6"
//		"models/humans/group01/female_01.mdl" : "Female 1"
//		"models/humans/group01/female_02.mdl" : "Female 2"
//		"models/humans/group01/female_03.mdl" : "Female 3"
//		"models/humans/group01/female_04.mdl" : "Female 4"
//		"models/humans/group01/female_06.mdl" : "Female 5"
//		"models/humans/group01/female_07.mdl" : "Female 6"
//		"models/humans/male_cheaple.mdl" : "Cheaple Male 1"
//		"models/odessa.mdl" : "Odessa. DO NOT USE."
//	]
//
//	ExpressionOverride(string) : "Facial expression override"
//
//	notifynavfailblocked(choices) : "Fire output when Nav is blocked?" : 0 =
//	[
//		0 : "No"
//		1 : "Yes"
//	]
//
//	// Inputs
//	input SetExpressionOverride(string) : "Set facial expression override"
//
//	input StartPatrolling(void) : "Patrol whenever I'm idle or alert."
//	input StopPatrolling(void) : "Stop patrolling when I'm idle or alert."
//	input SetCommandable(void) : "Make a previously uncommandable citizen commandable"
//	input SetMedicOn(void) : "Set the medic flag on. Will not change the model or skin of the citizen."
//	input SetMedicOff(void) : "Set the medic flag off. Will not change the model or skin of the citizen."
//	input SetAmmoResupplierOn(void) : "Set the ammo-resupplier flag on. Will not change the model or skin of the citizen."
//	input SetAmmoResupplierOff(void) : "Set the ammo-resupplier flag off. Will not change the model or skin of the citizen."
//
//	input SetReadinessLow(void) : "Set readiness to calmest state (Bored)"
//	input SetReadinessMedium(void) : "Set readiness to moderate (Alert)"
//	input SetReadinessHigh(void) : "Set readiness to highest. (Combat imminent)"
//	input LockReadiness(float) : "Lock readiness at current setting for x seconds -1 = forever, 0 = unlock now"
//
//	// Outputs
//	output OnJoinedPlayerSquad(void) : "Fires when joins player squad"
//	output OnLeftPlayerSquad(void) : "Fires when leaves player squad"
//	output OnFollowOrder(void) : "Fires when ordered to follow player"
//	output OnStationOrder(void) : "Fires when ordered to a location by player"
//	output OnPlayerUse(void) : "Fires when a player +USEs the citizen"
//	output OnNavFailBlocked(void) : "Fires when this Citizen's movement fails because he/she is blocked."
//]

@BaseClass base(BaseNPC) = JetpackBase
[
    // NOTE: These flags are identical to those in BaseGrunt--any additions need to be orthogonal to the base grunt (below)
    spawnflags(Flags) = 
	[
		65536 :  "Start LookOff" : 0
		131072 : "Start sitting" : 0
		262144 : "Can trigger DNA scanner" : 0
		524288 : "One hit kill" : 0
	//	 DO NOT USE 1048576--we always set this internally for Jetpack guys
	    2097152 : "Relative pathnode follow" : 1
	    4194304 : "Ignore LoS when on relative pathnode follow" : 0
	    8388608 : "Double speed" : 0
	]
	
    KeepBackDistance(float) : "Keepback distance" : 128 : "Distance to keep away from player."
	MaxFireRange(float) : "Maximum Fire Range" : 768 : "Maximum fire range. 0 = infinite range"
    
    input ChangePathTrack(target_destination) : "Tell the jetpack to move to a new path."
    input EnableRelativePathnode(void) : "Enable relative pathnode follow."
    input DisableRelativePathnode(void) : "Disable relative pathnode follow."
    
    input ActivateJets(void) : "Turn on the jetpack jets if they're not already on."
    input DeactivateJets(void) : "Turn off the jetpack jets if they're not already off."

    input EnableForcePath(void) : "Force this guy to strictly follow the path from one node to the next."
    input DisableForcePath(void) : "Disable forced pathnode following.  Will still be bound to the track."
]

@NPCClass base(JetpackBase) studio("models/characters/SintekGrunt/SintekGrunt.mdl") = npc_sintek_jetpack : "Sintek Jetpack Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_assault_rifle" =
	[
		"weapon_assault_rifle" : "Assault Rifle"
	]
]

@NPCClass base(JetpackBase) studio("models/characters/MobGrunt/MobGrunt.mdl") = npc_druglab_jetpack : "Druglab Jetpack Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_assault_rifle" =
	[
		"weapon_assault_rifle" : "Assault Rifle"
	]

	KeepBackDistance(float) : "Keepback distance" : 512 : "Distance to keep away from player."
]

@NPCClass base(JetpackBase) studio("models/characters/MobGrunt/MobGrunt.mdl") = npc_druglab_elite_jetpack : "Elite Jetpack Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_rocket_launcher" =
	[
		"weapon_rocket_launcher" : "Rocket launcher"
	]
	
	KeepBackDistance(float) : "Keepback distance" : 512 : "Distance to keep away from player."
]


@BaseClass base(BaseVehiclePassengerNPC, RappelNPC) = BaseGrunt
[
    // NOTE: These flags are identical to those in Jetpack--any additions need to be added to the jetpack base class (above)
	spawnflags(Flags) = 
	[
		65536 :  "Start LookOff" : 0
		131072 : "Start sitting" : 0
		262144 : "Can trigger DNA scanner" : 0
		524288 : "One hit kill" : 0
		1048576 : "Don't drop secondary ammo" : 0
		// (2097152 - 8388608 used by jetpacks)
		16777216 : "Don't secondary fire" : 0
	]

	NumGrenades(choices) : "Number of Grenades" : "5" =
	[
		"0" : "None"
		"1" : "1"
		"2" : "2"
		"3" : "3"
		"4" : "4"
		"5" : "5"
		"6" : "6"
		"7" : "7"
		"8" : "8"
		"9" : "9"
		"10" : "10"
		"999999" : "Unlimited"
	]
	
	GrenadeHeight(float) : "Grenade toss height" : 0 : "If grunt has more vertical distance than this from the player, become grenade happy."

//	 Inputs
	input LookOn(void) : "Look normally"	
	input LookOff(void) : "Don't look for myself, use other squad member's eyes"
	input StartPatrolling(void) : "Patrol whenever I'm idle or alert."
	input StopPatrolling(void) : "Stop patrolling when I'm idle or alert."
	input ThrowGrenades(bool) : "Toggles *really* throwing lots of grenades."
]

@NPCClass base(BaseGrunt) studio("models/characters/SintekGrunt/SintekGrunt.mdl") = npc_sintek_grunt : "Sintek Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_assault_rifle" =
	[
		"weapon_scattergun" : "Scatter Gun"
		"weapon_assault_rifle" : "Assault Rifle"
		"weapon_npc_pistol" : "Pistol"
	]
]

@NPCClass base(BaseGrunt) studio("models/characters/MobGrunt/mobgrunt.mdl") = npc_druglab_grunt_pistol : "Druglab Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_npc_pistol" =
	[
		"weapon_npc_pistol" : "Pistol"
	]
]

@NPCClass base(BaseGrunt) studio("models/characters/MobGrunt/mobgrunt.mdl") = npc_druglab_grunt_scattergun : "Druglab Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_scattergun" =
	[
		"weapon_scattergun" : "Scatter Gun"
	]
]

@NPCClass base(BaseGrunt) studio("models/characters/MobGrunt/mobgrunt.mdl") = npc_druglab_grunt_assault_rifle : "Druglab Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_assault_rifle" =
	[
		"weapon_assault_rifle" : "Assault Rifle"
	]
]

@NPCClass base(BaseGrunt) studio("models/characters/MobGrunt/mobgrunt.mdl") = npc_druglab_grunt_elite : "Elite Grunt"
[
    additionalequipment(choices) : "Weapons" : "weapon_chaingun" =
	[
		"weapon_chaingun" : "Chaingun"
	]
]

@NPCClass base(BaseNPC) studio("models/characters/quadralex/quadralex.mdl") = npc_quadralex : "Quadralex"
[

    //throwspeed(float) : "Ragdoll throw speed" : "3.0f" : "Multiplier for ragdoll throw speed"
    //ragdollweight(float) : "Ragdoll weight" : "25.0f" : "Weight of the thrown ragdolls"
    //throwspread(float) : "Ragdoll throw spread" : "10.0f" : "Width in degrees of the cone that the ragdoll can be thrown in"
    //timeout(float) : "Wait until running" : "10.0f" : "Time to wait before running to next node in Demolition Derby mode"

    Behavior(choices) : "Behavior type" : "0" =
    [
        "0" : "Default"
    //    "1" : "Throw ragdolls"
        "2" : "Pace"
    //    "3" : "Demolition derby"
    ]
    
	spawnflags(Flags) =
	[
		65536 : "Always see through breakables to acquire an enemy" : 0
		131072 : "Use inside footsteps" : 0
		262144 : "Invincible" : 0
	]

//	 Inputs
	input SetDefaultBehavior(void) : "Causes the Quadralex to resume default behavior (smashing phys objs)"
	//input SetRagdollBehavior(void) : "Causes the Quadralex to reach and throw ragdolls in addition to default behavior"
	input SetPaceBehavoir(void) : "Causes the Quadralex to pace back and forth and occasionally ram the walls instead of default behavior"
	//input SetDemolitionDerby(void) : "Causes the Quadralex to dodge the player's car in addtition to default behavior"
	
	input SetShoveTarget(string) : "Sets a shove target to attack"
	input SetChargeTarget(string) : "Sets a charge target to attack"
	input ClearChargeTarget(void) : "Clear the charge target"
	input Ragdoll(void) : "Causes the Quadralex to die, regardless of health"
	
	input Stop(void) : "Causes the Quadralex to stop running on the current path_track"
	
	input SetRunTarget(string) : "Sets the name of the entity to run to when damage or timeout conditions are met in demolition derby mode"
		
//	 Outputs
	output OnSeeHiddenPlayer(void) : "Fires when the current enemy is seen while trying to hide"
	output OnSmellHiddenPlayer(void) : "Fires when the current enemy is smelled while trying to hide"
	//output OnRun(void) : "Fires when the Quadralex runs to the next goal (demolition derby mode only)"
]

@BaseClass base(BaseHelicopter) = AssaultChopper
[
    spawnflags(Flags) = 
	[
		65536 :  "Loud rotor wash sound" : 0
		131072 : "Missiles on" : 0
		262144 : "Helicopter lights" : 0
		524288 : "Ignore avoid spheres+boxes" : 0
		1048576 : "More aggressive attacks" : 0
	]

	InitialSpeed(string) : "Initial Speed" : "0"
	GracePeriod(float) : "Grace Period" : "2.0" : "Time in seconds the helicopter has to see the player before he starts shooting"
	PatrolSpeed(float) : "Patrol Speed" : "0" : "Speed at which the helicopter moves if he has no enemy."
	InitialHealth(integer) : "Initial Health" : 0 : "If set, the initial health of the helicopter"
	
	MissileSpeed(float) : "Missile speed" : "600.0" : "Speed the missile flies at in units per second"
	MissileSpin(float) : "Missile spin" : "360.0" : "Degrees per second the missile spins"
	MissileDamage(float) : "Missile damage" : "40.0" : "Amount of damage the missile does"
	MissileDamageRadius(float) : "Missile damage radius" : "120.0" : "Radius the missile does damage in in world units"
	
	CrateDamage(float) : "Falling crate damage" : "0.0" : "Amount of damage a func_physbox will do if it hits the helicopter"

//	 Inputs
	input FireMissileBarrage(void) : "Fire a missile barrage at the current target"
	input FireSingleMissile(void) : "Fire a single missile at the current target"
	input SetMissileTarget(string) : "Set the missile target to shoot at"
	input GunOn(void) : "GunOn"
	input GunOff(void) : "GunOff"
	input MissileOn(void) : "MissileOn"
	input MissileOff(void) : "MissileOff"
	input EnableRotorWash(void) : "Turns on rotor wash effects"
	input DisableRotorWash(void) : "Turns off rotor wash effects"
	input EnableRotorSound(void) : "Turns on rotor sounds"
	input DisableRotorSound(void) : "Turns off rotor sounds"
	input StartTrailingVehicle(void) : "Starts the chopper trailing enemy vehicles and shooting at them."
	input StartDefaultBehavior(void) : "Starts the chopper in the mode where he always stops at nav points instead of stopping anywhere in between nav points."
	input StartBullrushBehavior(void) : "Starts the chopper bullrushing the player."
	input SetHealthFraction(float) : "Sets the chopper health as a percentage of max health"

	input EnableDeadlyShooting(void) : "Starts the chopper being deadly to on-foot players"
	input DisableDeadlyShooting(void) : "Stops the chopper being deadly to on-foot players"

	input StartNormalShooting(void) : "The chopper will fire in short bursts. Good for on-foot experiences"
	input StartLongCycleShooting(void) : "The chopper fires in long bursts"
	input StartContinuousShooting(void) : "The chopper fires continuously."

	input ResetIdleTime(void) : "Allows the helicopter to fire immediately if he's not in the middle of charging or firing"
	input SetAngles(string) : "Instantly snaps the orientation of the helicopter (Pitch Yaw Roll)"
	input BecomeIndestructible(void) : "Makes the helicopter take no more damage"

	input DisablePathVisibilityTests(void) : "When the helicopter moves, he will not check for visibility from the path_track to the enemy to cull out path_tracks"
	input EnablePathVisibilityTests(void) : "When the helicopter moves, he will only move to path_tracks that have line-of-sight to the enemy"

//	 Outputs
	output OnHealthChanged(integer) : "Fires when the helicopter health changes. The integer is the percentage of health the chopper has from 0-100."
]

@NPCClass base(AssaultChopper) studio("models/vehicles/sintek_helicopter/sintek_helicopter.mdl" ) = npc_druglab_helicopter : "Druglord Helicopter"
[
]

@NPCClass base(TalkNPC,Parentname,BaseVehiclePassengerNPC) studio() = npc_jessica : "Jessica"
[
	model(studio) : "World model" : "models/characters/Jessica/Jessica.mdl"

	additionalequipment(choices) : "Weapons" : "weapon_smg" =
	[
		"weapon_smg" : "SMG"
		"0"  : "Nothing"
	]
	
	spawnflags(Flags) =
	[
		65536 : "Invulnerable" : 1
	]
	
	input ThrowItemAtPlayer(string) : "Throw an item to the player"
	input SetPrimaryAmmoCountToThrow(integer) : "Set how much primary ammo will be included with any weapon that is thrown using ThrowItemAtPlayer"
	input SetSecondaryAmmoCountToThrow(integer) : "Set how much secondary ammo will be included with any weapon that is thrown using ThrowItemAtPlayer"
	input HolsterWeapon(integer) : "Jessica puts her weapon away."
]

@NPCClass base(TalkNPC) studio() = npc_jc : "JC"
[
	model(studio) : "World model" : "models/characters/JC/jc_torso.mdl"

	spawnflags(Flags) = 
	[
		65536 : "Ignore speech semaphore" : 0
	]
]

@NPCClass base(TalkNPC) studio() = npc_count : "Count"
[
	model(studio) : "World model" : "models/characters/count/count.mdl"

	spawnflags(Flags) = 
	[
		65536 : "Ignore speech semaphore" : 0
	]
	
	input InterrogationStart(void) : "Let the player start interrogating."
	input InterrogationStop(void) : "Player stops interrogating."
]

@NPCClass base(TalkNPC,Studiomodel) studio() = npc_generic_actor : "Generic Actor for Choreographies"
[
	heads(integer) : "Heads" : 0 : "Some models have different heads.  Set this to a number other than 0 to use that head instead of the default or -1 for a random head."
	
	spawnflags(Flags) = 
	[
		65536 : "Ignore speech semaphore" : 0
		131072 : "Invincible" : 0
	]
	
	additionalequipment(choices) : "Weapons" : "0" =
	[
		"weapon_scattergun" : "Scatter Gun"
		"weapon_assault_rifle" : "Assault Rifle"
		"weapon_npc_pistol" : "Pistol"
		"0" : "Nothing"
	]
	
	bloodColor(choices) : "Blood Color" : "247" =
	[
		"247" : "Red"
		"195" : "Yellow"
		"-1" : "Don't bleed"
	]

	dontHammerBBox(integer) : "Don't Hammer BBox" : 0 : "Set this to 1 if you don't want the engine to hammer the bounding box (unwise if the npc moves/animates)"
	
	initialHealth(integer) : "Initial Health" : 8 : "The initial health of the generic actor"
	
	//input PlayerCollide(bool) : "Turns player collision with this entity on and off."
]

@NPCClass base(TalkNPC,Studiomodel) studio() = npc_hologram : "Generic Hologram-effect Actor for Choreographies"
[
	input HologramOn(void) : "Turn the hologram on"
	input HologramOff(void) : "Turn the hologram off"
	output HologramOnDone(void) : "Fires when the hologram's turn-on effect is finished playing."
	output HOlogramOffDone(void) : "Fires when the hologram's turn-off effect is finished playing."
]

@NPCClass base(BaseNPC, Parentname) studio("models/characters/Mutants/Minor/minor.mdl") = npc_recombinant_minor : "Recombinant Minor"
[
]

@NPCClass base(BaseNPC, Parentname) studio("models/characters/Mutants/Major/major.mdl") = npc_recombinant_major : "Recombinant Major"
[
	SpawnType(choices) : "Spawn Type" : 0: "Type to spawn (Converted or Normal)" =
	[
		0 : "Random"
		1 : "Normal"
		2 : "Converted"
	]
]

@NPCClass base(BaseNPC) studio("models/characters/SintekGrunt/SintekGrunt.mdl") = npc_sniper : "Sniper"
[
	radius(integer) : "Patience Radius" : 0
	misses(integer) : "Initial Misses" : 0
	beambrightness(integer) : "Beam Brightness (0 to 255)" : 100

	shielddistance(float) : "Bullet shield distance" : 64
	shieldradius(float) : "Bullet shield radius" : 48

//	 Inputs
	input EnableSniper(void) : "Enable Shooting"
	input DisableSniper(void) : "Disable Shooting"
	input SetDecoyRadius(integer) : "Set Decoy Radius"
	input SweepTarget(string) : "Sweep a Target"
	input SweepTargetHighestPriority(string) : "Drop everything and sweep this target!"
	input SweepGroupRandomly(string) : "Randomly Sweep a Group"

	spawnflags(Flags) = 
	[
		65536 :  "Hidden" : 0
		131072 : "Laser Viewcone" : 0
		262144 : "No Corpse" : 0
		524288 : "Start Disabled" : 0
	]
]

@PointClass base(Targetname, Parentname) iconsprite("editor/info_target.vmt")  = info_snipertarget : "Sniper Target"
[
	speed(integer) : "Sweep to speed" : 2
	groupname(string) : "Group Name"
	spawnflags(Flags) =
	[
		1 : "Shoot Me" : 0
		2 : "No Interruptions" : 0
		4 : "Snap Shot" : 0
		8 : "Resume if Interrupted" : 0
		16: "Snap to me" : 0
	]
]

//-------------------------------------------------------------------------
//
// Vehicles
//
//-------------------------------------------------------------------------

@PointClass base(BaseDriveableVehicle) studioprop() = prop_vehicle_sin :
	"Sin Vehicle"
[
	model(studio) : "World model" : "models/vehicles/sin_car/sin_car.mdl"
	vehiclescript(string) : "Vehicle Script File" : "scripts/vehicles/sincar.txt"
	health(Integer) : "Health" : 100
	EnableUse(Integer) : "Enable vehicle use system ( 0=No, 1=Yes)" : 1
	ViewsLocked(integer) : "Lock passenger views ( 0=No, 1=YEs)" : 0
	InfiniteAmmo(Integer) : "Give infinite ammo to the passengers (0=No,1=Yes)" : 1
	Invunerable(Integer) : "Can cannot be destroyed if invunerable" : 1
	DamageTolerance(float) : "Damage Tolerance" : 20
	MonitorActive(integer) : "Vehicle Monitor Active" : 0
	MonitorCamera(string) : "Monitor Camera Name" : ""
	HintsEnabled(integer) : "Enable Hints" : 1
	DriverDoorLocked(Integer) : "Driver's door is locked. (0=No,1=Yes)" : 0

	input EnterVehicle(integer) : "Force activator into the provided vehicle role. (0=Driver,1=Passenger,2=Gunner)"
	input ExitVehicle(integer) : "Forces passenger out of the vehicle. (0=Driver,1=Passenger)"
	input EnableUse(bool) : "Enable or Disable use function inside vehicle."
	input SetView(integer) : "Set the activators view inside the vehicle."
	input LockView(integer) : "Lock all passenger views"
	input OpenDoor(integer) : "Opens a specific door"
	input OpenWindow(integer) : "Open a specific window"
	input CloseDoor(integer) : "Close a specific door"
	input CloseWindow(integer) : "Close a specific window"
	input OpenDoors(void) : "Open all doors"
	input CloseDoors(void) : "Close all doors"
	input OpenWindows(void) : "Open all windows"
	input CloseWindows(void) : "Close all windows"
	input HeadlightOn(void) : "Turn on headlights"
	input HeadlightOff(void) : "Turn off headlights"
	input WipersOn(void) : "Turn on wipers"
	input WipersOff(void) : "Turn off wipers"
	input MonitorOn(void) : "Turn Monitor On"
	input MonitorOff(void) : "Turn Monitor Off"
	input SetCamera(string) : "Set Monitor Camera"
	input RadioOn(void) : "Turn Radio On"
	input RadioOff(void) : "Turn Radio Off"
	input SetRadioStation(integer) : "Set the radio station"
	input EnableHints(integer) : "Enable Hints (0 = Disable, 1 = Enable)"
	input EnableAmmo(integer) : "Enable Ammo (0 = Disable, 1 = Enable)"

	output DoorOpen(integer) : "Door opened event"
	output DoorClosed(integer) : "Door Closed event"
	output WindowOpen(integer) : "Window opened event"
	output WindowClosed(integer) : "Window Closed event"
	output UseBox(integer) : "This output is triggered when a vehicle use box is used, the activator is the user of the use box"
	output ViewChanged(integer) : "This output is triggered when a passenger in the vehicle changes views"
]

//-------------------------------------------------------------------------
//
// Weapons
//
//-------------------------------------------------------------------------

@PointClass base(Weapon) studio("models/weapons/w_magnum.mdl") = weapon_magnum : "Auto Magnum" []
@PointClass base(Weapon) studio("models/weapons/w_assault_rifle/w_assault_rifle.mdl") = weapon_assault_rifle : "Assault Rifle" []
@PointClass base(Weapon) studio("models/weapons/w_scattergun/w_scattergun.mdl") = weapon_scattergun : "Scatter Gun" []
@PointClass base(Weapon) studio("models/weapons/w_npc_pistol/w_npc_pistol.mdl") = weapon_npc_pistol : "Pistol" []
@PointClass base(Weapon) studio("models/weapons/w_sniper_rifle.mdl") = weapon_sniper_rifle : "Sniper Rifle" []
@PointClass base(Weapon) studio("models/weapons/w_rocket_launcher.mdl") = weapon_rocket_launcher : "Rocket Launcher" []
@PointClass base(Weapon) studio("models/weapons/grenades/frag_grenade.mdl") = weapon_grenade : "Frag Grenade" []
@PointClass base(Weapon) studio("models/weapons/w_magnum.mdl") = weapon_flaregun : "Flare Gun" []
@PointClass base(Weapon) studio("models/weapons/w_smg/w_smg.mdl") = weapon_smg: "SMG" []
@PointClass base(Weapon) studio("models/weapons/w_assault_rifle/w_assault_rifle.mdl") = weapon_chaingun: "Chaingun" []

//-------------------------------------------------------------------------
//
// Enviromental 
//
//-------------------------------------------------------------------------

@PointClass base(Targetname,Angles) iconsprite("editor/env_fire") color(0 180 0) = env_poison_gas : "This entity causes damage to all other entities within it's radius."
[
	active(integer) : "active" : 1 : "Gas cloud active on spawn (1 = Yes, 0 = NO)"
	damage(float) : "Damage" : 20 : "Damage per second inflicted by this poison."
	radius(float) : "Radius" : 300 : "Poison gas radius"
	duration(float) : "Duration" : 30 : "Duration in seconds (0 = Infinite)"
	spawnrate(float) : "SpawnRate" : 48 : "Particle Spawn Rate"

	gastype(choices) : "Gas Type" : 0: "Type of gas" =
	[
		0 : "U4"
		1 : "ANTIGEN"
		2 : "RADIATION"
		3 : "INERT"
	]

	input TurnOn(void) : "Turn Gas On"
	input TurnOff(void) : "Turn Gas Off"
	input SetRadius(float) : "Set Gas cloud radius"
	input SetDuration(float) : "Set Gas cloud duration( 0 = Infinite)"
	input SetSpawnRate(float) : "Set Gas particle spawn rate"
	input SoundOn(bool) : "Turn gas cloud on or off"
	input SetStartColor(Vector) : "Set the color of the gas at start"
	input SetEndColor(Vector) : "Set the color of the gas at end"
]


@PointClass base(Targetname) iconsprite("editor/env_soundscape") color(0 180 0) = env_radio : "Radio"
[
	RadioOn(Integer) : "RadioOn" : 1 : "Radio on or off."
	ScriptFile(string) : "ScriptFile" : "scripts/radio.txt" : "Script file containing station information"
	volume(float) : "Volume" : 100 : "Radio Volume"

	input TurnOn(void) : "Radio On"
	input TurnOff(void) : "Radio Off"
	input NextStation(void) : "Next Station"
	input PrevStation(void ) : "Prev Station"
	input SetStation(integer) : "Set Station"
	input SetVolume(integer) : "Set Volume (0-100)"
	input SetScript(string) : "Set Script"
]

@PointClass base(Targetname) iconsprite("editor/env_fade") = env_faint : "An entity that can perform screen/audio fades."
[
	IsActive(Integer) : "IsActive" : 0 : "Is this entity currently active."
	FadeTime(float) : "FadeTime" : 3 : "How many seconds to fade in/out."

	// Inputs
	input BeginFaint(void) : "Start the screen fade."
	input EndFaint(void) : "End the screen fade."

	// Outputs
	output OnBeginFaint(void) : "Fired when the faint has begun."
	output OnEndFaint(void) : "Fired when the faint is ending."
]

//-------------------------------------------------------------------------
// Grandfathered containers
//-------------------------------------------------------------------------
@PointClass base(prop_physics) studioprop("models/containers/oxygen_tank_large.mdl")= prop_propane_tank : "(CHANGE to prop_oxygen_tank_large) Oxygen tank Large" []
@PointClass base(prop_physics) studioprop("models/containers/oxygen_tank_small.mdl")= prop_oxygen_tank : "(CHANGE to prop_oxygen_tank_small) Oxygen tank Small" []
@PointClass base(prop_physics) studioprop("models/containers/mutagen_barrel.mdl")   = prop_u4_barrel: "(CHANGE TO prop_mutagen_barrel) Mutagen Barrel" []
@PointClass base(prop_physics) studioprop("models/items/antigen/antigentank.mdl")	= prop_antigen_explosive_barrel: "Explosive Antigen Barrel" []

//--------------------------------------------------------------------------
// Containers
//--------------------------------------------------------------------------
@PointClass base(prop_physics) studioprop("models/containers/oxygen_tank_large.mdl")= prop_oxygen_tank_large :	"Oxygen Tank (Large)" []
@PointClass base(prop_physics) studioprop("models/containers/oxygen_tank_small.mdl")= prop_oxygen_tank_small :	"Oxygen Tank (Small)" []
@PointClass base(prop_physics) studioprop("models/containers/acetylene_tank.mdl")   = prop_acetylene_tank :		"Acetyline Tank" []
@PointClass base(prop_physics) studioprop("models/containers/mutagen_barrel.mdl")   = prop_mutagen_barrel:		"Mutagen Leaking Barrel" []
@PointClass base(prop_physics) studioprop("models/items/antigen/antigentank.mdl")	= prop_antigen_canister:	"Antigen Canister" []
@PointClass base(prop_physics) studioprop("models/containers/exploding_barrel.mdl") = prop_exploding_barrel:	"Exploding Barrel" []

//--------------------------------------------------------------------------
// Payphone
//--------------------------------------------------------------------------
@PointClass base(Targetname,Angles) studio("models/props_general/payphone_01.mdl") = prop_phone : "Phone" 
[
	Disabled(integer) : "Disabled" : 0
	FailSound(string) : "Fail Sound" : "" : "Sound played when bad phone number is entered"
	KeypadName(string) : "Keypad Panel Name" : "prop_keypad" : "VGUI interface name"
	PhoneBook(string) : "Phone Book" : "scripts/phonebook.txt" : "Key-Value file containing phone numbers and sounds"

	input DialNumber(string) : "Dial a Phone Number"
	input Enable(void) : "Enable the phone"
	input Disable(void) : "Disabled the phone"
]

//--------------------------------------------------------------------------
// 
// Actions
//
//---------------------------------------------------------------------------
@PointClass base(Angles) color(0 180 0) = action : "This action represents an entity looking at something, such as the player looking at an NPC."
[
	name(string) : "Name" : "" : "Name of this entity, such as action123."
	Category(string) : "Category" : "" : "Category of this action, such as Use."
	Subcategory(string) : "SubCategory" : "" : "Sub-category of this action, such as Throw."
	OwnerClass(string) : "OwnerClass" : "" : "Classname of the Owner of this action, such as npc_grunt."
	OwnerName(string) : "OwnerName" : "" : "Name of the Owner of this action, such as Bob."
	SubjectClass(string) : "SubjectClass" : "" : "Classname of the Subject of this action, such as prop_dynamic."
	SubjectName(string) : "SubjectName" : "" : "Name of the Subject of this action, such as myBigBarrel."
	Time(float) : "Time" : 0 : "Time this action occured, from the start of the map."
]

//---------------------------------------------------------------------------
// Dynamic difficulty trigger
@SolidClass base(TriggerOnce) = trigger_dynamic_difficulty :
	"A trigger volume that marks expected data when the player trips this trigger for the dynamic difficulty system to use."
[
	spawnflags(flags) = 
	[
		1024: "Don't destroy after triggering" : 0
	]
	
	EndOfGame(integer) : "Marks end of the game" : 0 : "Establishes that the game is over, stats-wise, for a non-arena single player game."
	EstimatedTime(float) : "Estimated time to get here" : 0 : "Estimated time elapsed in seconds it takes to get here from the last DD trigger or the beginning of the map if no trigger."
	EstimatedDifficulty(choices) : "Expected upcoming difficulty level." : 2 : "What the system should expect for the upcoming difficulty until the next DD trigger." =
	[
		0 : "Very Easy"
		1 : "Easy"
		2 : "Medium"
		3 : "Hard"
		4 : "Very Hard"
	]
]

//---------------------------------------------------------------------------
// Secret trigger
@SolidClass base(TriggerOnce) = trigger_secret :
	"A trigger volume that marks a secret area so the game can track them."
[
	
]

//----------------------------------------------------------------------------
// env_radio_message (sends a police radio message to the player)
//----------------------------------------------------------------------------
@PointClass base(Targetname) color( 205 255 225 ) = env_radio_message : "Entity for sending police radio messages from friendly npcs to the player.  Takes a speaker, message, and a priority.  Inputs allow changing these variables, and Dispatch issues the message."
[
	speaker(string) : "Speaker" : "" : "Who is sending the message.  Should be a classname (npc_jessica, npc_jc)"
	message(string) : "message" : "" : "The message to send.  This should be the name of a sound specified in scripts/npc_sounds_police_radio.txt."
	priority(choices) : "Priority" : 0 : "Priority of the message.  Objectives override extraneous messages.  You can only have one message of each type at a time.  Use extraneous for non-essential messages." =
	[
		0 : "Objective"
		1 : "Extraneous"
	]

	input SetSpeaker(string) : "Set who is sending the message.  Should be a classname (npc_jessica, etc.)"
	input SetMessage(string) : "Set the scene or .wav file of the message."
	input SetPriority(string) : "Set the priority of the message.  Objectives override extraneous messages.  You can only have one message of each type at a time.  Use extraneous for non-essential messages."
	input Dispatch(string) : "Dispatch a message (if none specified, using the message property).  This should be the name of a sound specified in scripts/npc_sounds_police_radio.txt."
	input Remove(void) : "Removes a message that has been dispatched. No longer available to the player."

	output OnDispatch(void) : "Fires when a message from this police radio is dispatched."
	output OnHeard(void) : "Fires when a message from this police radio is heard by the player."
]



//--------------------------------------------------------------------------
// 
// GUIs
//
//---------------------------------------------------------------------------

@PointClass base(vgui_screen_base) size(-4 -4 -4, 4 4 4)  = keypad : "A door keycode pad" 
[
    combination(string) : "Combination" : "" : "The combination that will cause the keypad to fire the CorrectCode output."
    
    input Disable(void) : "Enables the keypad"
	input Enable(void) : "Disables the keypad"
	
	output CorrectCode(void) : "Fires when the correct code is entered."
	output WrongCode(void) : "Fires when the wrong code is entered."
]


@PointClass base(Targetname, Parentname) size(-4 -4 -4, 4 4 4) = info_challenge : 
	"Entity used to get information about the challenge system"
[
	input GetInitialChallenge(void) : "Fires an output that contains the value of the initial challenge as a parameter"
	input GetCurrentChallenge(void) : "Fires an output that contains the value of the current challenge as a parameter"
	input GetChallengeDifference(void) : "Fires an output that contains the difference between the current and initial challenge as a parameter"
	
	output OnInitialChallenge(float) : "Fires when the GetInitialChallenge input is called"
	output OnCurrentChallenge(float) : "Fires when the GetCurrentChallenge input is called"
	output OnChallengeDifference(float) : "Fires when the GetChallengeDifference input is called"
]