
// == IMPORTANT == //

// This FGD only works in Slartibarty's / Slammin Hammer! https://knockout.chat/thread/992/1


//=============================================================================
//
// Fully standardised general game definition file (.fgd) for Open Fortress Deathmatch
// Does not contain HL2 entities, add ofd_fic2_hl2.fgd to Hammer's config if you want them
// Researched and overhauled/updated by ficool2, based roughly on A Boojum Snark's FGD, seen here http://forums.tf2maps.net/showthread.php?t=4674
// Thanks to KaidemonLP for datamap dumps
// 30th of July 2019
//
//=============================================================================

@mapsize(-16384, 16384)

//-------------------------------------------------------------------------
// Hammer Tweaks
//-------------------------------------------------------------------------

@MaterialExclusion
[
	// Names of the sub-directories we don't want to load materials from, as they are useless
	"ambulance"
	"backpack"
	"cable"
	"console"
	"customcubemaps"
	"cubemaps"
	"debug"
	"detail"
	"editor-ficool2"
	"engine"
	"matsys_regressiontest"
	"hlmv"
	"hud"
	"logo"
	"maps"
	"models"
	"overviews"
	"perftest"
	"scripted"
	"shadertest"
	"vgui"
	"voice"
	"vr"
]

@AutoVisGroup = "Entities"
[
	"Cameras"
	[
     	"func_monitor"
		"game_intro_viewpoint"
		"info_camera_link"
		"info_observer_point"
		"point_camera"
		"point_commentary_viewpoint"
		"point_devshot_camera"
		"point_viewcontrol"
		"sky_camera"
	]
	"Instances"
	[
		"func_instance"
		"func_instance_parms"
		"func_instance_origin"
	]
	"Lights"
	[
		"light"
		"light_directional"
		"light_dynamic"
		"light_environment"
		"light_glspot"
		"light_spot"
	]
	"Sprites"
	[
		"env_sprite"
		"env_sprite_orientated"
		"env_glow"
		"env_lightglow"
	]
	"Propper"
	[
		"propper_lod"
		"propper_bodygroup"
		"propper_physgun_interactions"
		"propper_particles"
		"propper_cables"
		"propper_gibs"
		"propper_skins"
		"propper_model"
		"propper_physics"
	]
	"Sound"
	[
     	"ambient_generic"	 
		"env_microphone"
		"env_soundscape"
        "env_soundscape_proxy"
        "env_soundscape_triggerable"
		"trigger_soundscape"
		"info_target"
	]
]

@AutoVisGroup = "Tool Brushes"
[
	"Detail Blockers"
	[
		"func_detail_blocker"
	]
	"Vis Clusters"
	[
		"func_viscluster"
	]
]

@AutoVisGroup = "Custom"
[
	"AI/Choreography"
	[
	    "ai_ally_speech_manager"
	    "ai_battle_line"
	    "ai_changehintgroup"
	    "ai_changetarget"
	    "ai_goal_assault"
	    "ai_goal_follow"
	    "ai_goal_lead"
	    "ai_goal_lead_weapon"
	    "ai_goal_standoff"
	    "ai_hint"
	    "ai_relationship"
	    "ai_script_conditions"
	    "ai_sound"
	    "ai_speechfilter"
	    "aiscripted_schedule"
	    "assault_assaultpoint"
	    "assault_rallypoint"
		"cycler_actor"
	    "generic_actor"
		"logic_scene_list_manager"
		"logic_choreographed_scene"
		"info_hint"
        "info_node"
        "info_node_air"
        "info_node_air_hint"
        "info_node_climb"
        "info_node_hint"
        "info_node_link"
        "info_node_link_controller"
        "info_npc_spawn_destination"
		"monster_furniture"
		"monster_generic"
		"monster_resource"
		"npc_furniture"
		"npc_maker"
		"npc_template_maker"
		"npc_vehicledriver"
		"scripted_scene"
		"scripted_sentence"
		"scripted_sequence"
		"scripted_target"
	]
	"Logic"
	[
	    "commentary_auto"
        "filter_activator_class"
        "filter_activator_mass_greater"
        "filter_activator_name"
        "filter_activator_team"
        "filter_activator_tfteam"
        "filter_base"
        "filter_damage_type"
        "filter_enemy"
        "filter_multi"
        "filter_tf_bot_has_tag"
        "filter_tf_class"
        "filter_tf_condition"
        "filter_tf_damaged_by_weapon_in_slot"
        "filter_tf_player_can_cap"
		"func_passtime_no_ball_zone"
		"func_passtime_goalie_zone"
		"func_passtime_goal"
		"func_ladderendpoint"
		"func_useableladder"
        "game_end"
        "game_forcerespawn"
        "game_gib_manager"
        "game_intro_viewpoint"
        "game_player_equip"
        "game_player_team"
        "game_ragdoll_manager"
        "game_round_win"
        "game_score"
        "game_ui"
        "game_weapon_manager"
        "game_zone_player"
        "logic_active_autosave"
        "logic_auto"
        "logic_autosave"
        "logic_branch"
        "logic_branch_listener"
        "logic_case"
        "logic_choreographed_scene"
        "logic_collision_pair"
        "logic_compare"
        "logic_lineto"
        "logic_measure_movement"
        "logic_multicompare"
        "logic_navigation"
        "logic_proximity"
        "logic_relay"
        "logic_scene_list_manager"
        "logic_timer"
        "math_colorblend"
        "math_counter"
        "math_remap"
        "multisource"
        "passtime_logic"
		"player_loadsaved"
        "player_manager"
        "player_speedmod"
        "player_weaponstrip"
        "point_anglesensor"
        "point_angularvelocitysensor"
        "point_bonusmaps_accessor"
        "point_clientcommand"
        "point_gamestats_counter"
        "point_intermission"
        "point_playermoveconstraint"
        "point_populator_interface"
        "point_posecontroller"
        "point_proximity_sensor"
        "point_servercommand"
        "point_teleport"
        "point_template"
        "point_velocitysensor"
        "tanktrain_ai"
        "tanktrain_aitarget"
        "team_control_point"
        "team_control_point_master"
        "team_control_point_round"
        "team_round_timer"
        "team_train_watcher"
		"tf_gamerules"
        "tf_halloween_minigame"
        "tf_halloween_minigame_falling_platforms"
        "tf_logic_arena"
        "tf_logic_bonusround"
        "tf_logic_competitive"
        "tf_logic_cp_timer"
        "tf_logic_holiday"
        "tf_logic_hybrid_ctf_cp"
        "tf_logic_koth"
        "tf_logic_mann_vs_machine"
        "tf_logic_mannpower"
        "tf_logic_medieval"
        "tf_logic_minigames"
        "tf_logic_multiple_escort"
        "tf_logic_on_holiday"
        "tf_logic_player_destruction"
        "tf_logic_robot_destruction"
        "tf_logic_training_mode"
        "trigger"
        "trigger_add_or_remove_tf_player_attributes"
        "trigger_add_tf_player_condition"
        "trigger_apply_impulse"
        "trigger_autosave"
        "trigger_bot_tag"
        "trigger_brush"
        "trigger_capture_area"
        "trigger_catapult"
        "trigger_cdaudio"
        "trigger_changelevel"
        "trigger_gravity"
        "trigger_hurt"
        "trigger_ignite"
        "trigger_impact"
        "trigger_look"
        "trigger_multiple"
        "trigger_once"
        "trigger_particle"
        "trigger_passtime_ball"
        "trigger_player_respawn_override"
        "trigger_playermovement"
        "trigger_proximity"
        "trigger_push"
        "trigger_rd_vault_trigger"
        "trigger_remove"
        "trigger_remove_tf_player_condition"
        "trigger_serverragdoll"
        "trigger_soundscape"
        "trigger_stun"
        "trigger_teleport"
        "trigger_teleport_relative"
        "trigger_timer_door"
        "trigger_togglesave"
        "trigger_transition"
        "trigger_vphysics_motion"
        "trigger_wind"
	]
	"Bots/Navigation"
	[
        "archer_proxy"
        "base_boss"
        "bot_action_point"
        "bot_controller"
        "bot_generator"
        "bot_hint_engineer_nest"
        "bot_hint_sentrygun"
        "bot_hint_teleporter_exit"
        "bot_npc_archer"
        "bot_npc_decoy"
        "bot_proxy"
        "bot_roster"
		"eyeball_boss"
        "filter_tf_bot_has_tag"
		"func_nav_avoid"
        "func_nav_avoidance_obstacle"
        "func_nav_blocker"
        "func_nav_prefer"
        "func_nav_prerequisite"
		"func_suggested_build"
		"func_tfbot_hint"
        "ghost"
        "headless_hatman"
		"merasmus"
		"point_populator_interface"
		"populator_internal_spawn_point"
		"simple_bot"
		"tank_boss"
		"tf_bot"
		"tf_robot_destruction_robot"
		"tf_robot_destruction_robot_spawn"
		"tf_robot_destruction_spawn_group"
		"tf_zombie"
		"tf_zombie_spawner"
		"trigger_bot_tag"
	]
	"Performance"
	[
		"func_areaportal"
		"func_areaportalwindow"
		"func_occluder"
		"func_viscluster"
		"shadow_control"
		"water_lod_control"
	]
	"Visual"
	[
        "archer_proxy"
        "base_boss"
        "bot_npc_archer"
        "color_correction"
        "color_correction_volume"
        "cycler_actor"
        "cycler_flex"
        "dynamic_prop"
        "entity_bird"
        "entity_carrier"
        "entity_croc"
        "entity_medigun_shield"
        "entity_revive_marker"
        "entity_rocket"
        "entity_saucer"
        "entity_sign"
        "env_beam"
        "env_beverage"
        "env_blood"
        "env_bubbles"
        "env_credits"
		"env_cubemap"
        "env_detail_controller"
        "env_dustpuff"
        "env_dusttrail"
        "env_effectscript"
        "env_embers"
        "env_entity_dissolver"
        "env_entity_igniter"
        "env_entity_maker"
        "env_explosion"
        "env_fade"
        "env_fire"
        "env_fire_trail"
        "env_firesensor"
        "env_firesource"
        "env_fog_controller"
        "env_funnel"
        "env_global"
        "env_glow"
        "env_gunfire"
        "env_hudhint"
        "env_laser"
        "env_lightglow"
        "env_message"
        "env_movieexplosion"
        "env_muzzleflash"
        "env_particle_trail"
        "env_particlefire"
        "env_particlelight"
        "env_particlescript"
        "env_particlesmokegrenade"
        "env_physexplosion"
        "env_physimpact"
        "env_projectedtexture"
        "env_rockettrail"
        "env_rotorshooter"
        "env_screeneffect"
        "env_screenoverlay"
        "env_shake"
        "env_shooter"
        "env_smokestack"
        "env_smoketrail"
        "env_sniperdot"
        "env_spark"
        "env_splash"
        "env_sporeexplosion"
        "env_sporetrail"
        "env_sprite"
        "env_sprite_oriented"
        "env_spritetrail"
        "env_steam"
        "env_steamjet"
        "env_sun"
        "env_texturetoggle"
        "env_tonemap_controller"
        "env_tracer"
        "env_viewpunch"
        "env_wind"
        "env_zoom"
        "eyeball_boss"
        "func_breakable"
        "func_breakable_surf"
        "func_brush"
        "func_button"
        "func_conveyor"
        "func_door"
        "func_door_rotating"
        "func_dustcloud"
        "func_dustmotes"
        "func_fish_pool"
        "func_forcefield"
        "func_guntarget"
        "func_illusionary"
        "func_lod"
        "func_monitor"
        "func_movelinear"
        "func_physbox"
        "func_physbox_multiplayer"
        "func_plat"
        "func_platrot"
        "func_precipitation"
        "func_pushable"
        "func_reflective_glass"
        "func_rot_button"
        "func_rotating"
        "func_smokevolume"
        "func_tanktrain"
        "func_trackautochange"
        "func_trackchange"
        "func_tracktrain"
        "func_train"
        "func_traincontrols"
        "func_wall"
        "func_wall_toggle"
        "func_water"
        "func_water_analog"
        "func_weight_button"
        "generic_actor"
        "ghost"
        "gibshooter"
        "halloween_fortune_teller"
        "halloween_souls_pack"
        "halloween_zapper"
        "headless_hatman"
        "hightower_teleport_vortex"
        "info_lighting"
        "info_lighting_relative"
        "info_particle_system"
        "info_projecteddecal"
        "infodecal"
        "item_ammopack_full"
        "item_ammopack_medium"
        "item_ammopack_small"
        "item_armor"
        "item_bonuspack"
        "item_currencypack_custom"
        "item_currencypack_large"
        "item_currencypack_medium"
        "item_currencypack_small"
        "item_healthammokit"
        "item_healthkit_full"
        "item_healthkit_medium"
        "item_healthkit_small"
        "item_powerup_crit"
        "item_powerup_rune"
        "item_powerup_rune_temp"
        "item_powerup_uber"
        "item_sodacan"
        "item_teamflag"
        "keyframe_rope"
        "light"
		"light_directional"
		"light_dynamic"
        "light_environment"
        "light_spot"
        "mapobj_cart_dispenser"
        "material_modify_control"
        "merasmus"
        "merasmus_dancer"
        "momentary_door"
        "momentary_rot_button"
        "monster_furniture"
        "monster_generic"
        "monster_resource"
        "move_rope"
        "npc_concussiongrenade"
        "npc_contactgrenade"
        "npc_furniture"
        "npc_handgrenade"
        "obj_attachment_sapper"
        "obj_dispenser"
        "obj_sentrygun"
        "obj_teleporter"
        "passtime_ball"
        "phys_magnet"
        "physics_cannister"
        "physics_prop"
        "physics_prop_ragdoll"
        "player"
		"prop_detail"
		"prop_detail_sprite"
        "prop_door_rotating"
        "prop_dynamic"
        "prop_dynamic_ornament"
        "prop_dynamic_override"
        "prop_physics"
        "prop_physics_multiplayer"
        "prop_physics_override"
        "prop_physics_respawnable"
        "prop_ragdoll"
        "prop_soccer_ball"
        "prop_sphere"
        "prop_vehicle"
        "prop_vehicle_driveable"
        "shadow_control"
        "simple_bot"
        "simple_physics_brush"
        "simple_physics_prop"
        "spark_shower"
        "tank_boss"
        "tank_destruction"
        "teleport_vortex"
        "test_effect"
        "test_traceline"
        "tf_generic_bomb"
        "tf_glow"
        "tf_halloween_gift_pickup"
        "tf_halloween_pickup"
        "tf_merasmus_trick_or_treat_prop"
        "tf_powerup_bottle"
        "tf_projectile_arrow"
        "tf_projectile_ball_ornament"
        "tf_projectile_balloffire"
        "tf_projectile_cleaver"
        "tf_projectile_energy_ball"
        "tf_projectile_energy_ring"
        "tf_projectile_flare"
        "tf_projectile_grapplinghook"
        "tf_projectile_healing_bolt"
        "tf_projectile_jar"
        "tf_projectile_jar_gas"
        "tf_projectile_jar_milk"
        "tf_projectile_lightningorb"
        "tf_projectile_mechanicalarmorb"
        "tf_projectile_pipe"
        "tf_projectile_pipe_remote"
        "tf_projectile_rocket"
        "tf_projectile_sentryrocket"
        "tf_projectile_spellbats"
        "tf_projectile_spellfireball"
        "tf_projectile_spellkartbats"
        "tf_projectile_spellkartorb"
        "tf_projectile_spellmeteorshower"
        "tf_projectile_spellmirv"
        "tf_projectile_spellpumpkin"
        "tf_projectile_spellspawnboss"
        "tf_projectile_spellspawnhorde"
        "tf_projectile_spellspawnzombie"
        "tf_projectile_spelltransposeteleport"
        "tf_projectile_stun_ball"
        "tf_projectile_syringe"
        "tf_projectile_throwable"
        "tf_projectile_throwable_breadmonster"
        "tf_projectile_throwable_brick"
        "tf_projectile_throwable_repel"
        "tf_pumpkin_bomb"
        "tf_ragdoll"
        "tf_robot_destruction_robot"
        "tf_spell_meteorshowerspawner"
        "tf_spell_pickup"
        "tf_target_dummy"
        "tf_zombie"
        "training_annotation"
        "training_prop_dynamic"
        "vgui_screen"
        "vgui_screen_team"
        "vgui_slideshow_display"
        "wheel_of_doom"
        "wheel_of_doom_spiral"
	]
]

//-------------------------------------------------------------------------
// Base Classes
//-------------------------------------------------------------------------

// Every entity has this stuff, except for Hammer-internal entities
@BaseClass = BaseEntity
[ 
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."

	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	input ChangeVariable(string) : "Similar to AddOutput, except it changes an internal variable similar to logic_datadesc_accessor instead. Very dangerous, use with care."
	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input Touch(string): "Make the entity touch the specified entity."
	
	// Mapbase -- BaseEntity I/O
	input FireOutput(string) : "Fires the named output on this entity. Format: '<output name>:<activator>:<caller>:<parameter>:<delay>' (OnDeath:hl3cardgame:gaben). Everything beyond the output name is optional."
	input RemoveOutput(string) : "Removes all instances of the named output on this entity. Wildcards are supported, meaning you could just pass '*' to wipe all outputs from this entity."
	input CancelPending(void) : "Cancels any events fired by this entity that are currently pending in the I/O event queue."
	
	input SetLocalOrigin(vector) : "Sets this entity's origin in the map."
	input SetLocalVelocity(vector) : "Sets this entity's current velocity."
	input SetLocalAngularVelocity(vector) : "Sets this entity's current angular velocity."
	
	input AddSpawnFlags(integer) : "Adds spawnflag(s) to this entity. Many spawnflags have their respective numbers suffixed in this FGD."
	input RemoveSpawnFlags(integer) : "Removes spawnflag(s) to this entity. Many spawnflags have their respective numbers suffixed in this FGD."
	
	input SetTarget(target_destination) : "Sets this entity's target. This is specific to certain entities, particularly logic entities that involve a target."
	input SetOwnerEntity(target_destination) : "Sets this entity's owner entity. This has nothing to do with parenting and has more to do with collision and kill credits."
	
	input SetThinkNull(void) : "Sets this entity's general think function to null. Behavior varies from entity to entity.."

	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
	output OnKilled(void) : "Fires when this entity is removed with the 'Kill' input."
]

@BaseClass = Angles
[ 
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."
]

// Required for instances
@BaseClass = Origin
[ 
	origin(origin) : "Origin (X Y Z)" : : "The position of this entity's center in the world. Rotating entities typically rotate around their origin."
]

// This adds additional stuff to point entities that are networked
@BaseClass = BaseEntityPoint
[ 
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."

	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"

	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]

// Every BRUSH entity has this stuff, except for Hammer-internal entities
@BaseClass = BaseEntityBrush
[ 
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
 	origin(origin) : "Origin (X Y Z)" : : "The position of this entity's center in the world. Rotating entities typically rotate around their origin." 
// this causes too many issues, its better to leave it up to the user

	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	
	linedivider2(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]

// Some entities may have Render keyvalues but not anything else from BaseAnimating, also easier to change stuff incase the renderfx/rendermode part is more documentated
@BaseClass = Render
[ 
	rendermode(choices) : "Render Mode" : 0 : "Set a non-standard rendering mode on this entity." =
	[
		0: "Normal"
		1: "Color"
		2: "Texture"
		3: "Glow"
		4: "Solid/Alphatest"
		5: "Additive"
		6: "Environmental (not drawn)"
		7: "Additive Fractional Frame"
		8: "Alpha Add"
		9: "World Space Glow"
		10: "Don't Render"
	]	
	rendercolor(color255) : "Color (R G B)" : "255 255 255" : "Controls a color tint for the entity. Use white (255 255 255) for no modification to color."
	renderamt(integer) : "Transparency (0 - 255)" : 255 : "Transparency amount, requires a Render Mode other than Normal. 0 is invisible, 255 is fully visible."
	renderfx(choices) : "Render FX" : 0 : "Preset pattern of appearance effects." =
	[
		0: "Normal"
		1: "Slow Pulse"
		2: "Fast Pulse"
		3: "Slow Wide Pulse"
		4: "Fast Wide Pulse"
		5: "Slow Fade Away"
		6: "Fast Fade Away"
		7: "Slow Become Solid"
		8: "Fast Become Solid"
		9: "Slow Strobe"
		10: "Fast Strobe"
		11: "Faster Strobe"
		12: "Slow Flicker"
		13: "Fast Flicker"
		14: "No Dissipation"
		15: "Distort"
		16: "Hologram (Distort + fade)"
		17: "Scale Up"
		18: "Glow Shell"
		19: "Clamp Minimum Scale (sprites only)"
		20: "Environmental Rain"
		21: "Environmental Snow"
		22: "Spotlight FX"
		23: "Ragdoll (ragdolls the entity but does NOT kill it)"
		24: "Fade Wider Pulse"
	]
	//mindxlevel(choices) : "Minimum DirectX Level" : 0 = 
	//[
	//	0 : "Default (lowest)"
	//	60 : "DirectX 6.0"	
	//	70 : "DirectX 7.0"
	//	80 : "DirectX 8.0 (4600Ti)"
	//	81 : "DirectX 8.1 (FX5200)"
	//	90 : "DirectX 9.0 SM2.0"
	//	95 : "DirectX 9.5 SM3.0"
	//	100 : "DirectX 10.0"
	//]
	//maxdxlevel(choices) : "Maximum DirectX Level" : 0 = 
	//[
	//	0 : "Default (lowest)"
	//	60 : "DirectX 6.0"	
	//	70 : "DirectX 7.0"
	//	80 : "DirectX 8.0 (4600Ti)"
	//	81 : "DirectX 8.1 (FX5200)"
	//	90 : "DirectX 9.0 SM2.0"
	//	95 : "DirectX 9.5 SM3.0"
	//	100 : "DirectX 10.0"
	//]
	linedivider3(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	input Color(color255) : "Sets an RGB color for the entity."
	input Alpha(integer) : "Sets the entity's transparency to a number from 0 (invisible) to 255 (fully visible). Requires the entity to have its Render Mode set to a number other than 0."
	
	input SetRenderMode(integer) : "Sets this entity's render mode."
	input SetRenderFX(integer) : "Sets this entity's render FX."
	input SetViewHideFlags(integer) : "Sets this entity's view ID nodraw flags (takes raw flag combination)."
	input AddEffects(integer) : "Adds an entity effect."
	input RemoveEffects(integer) : "Removes an entity effect."
	input EnableDraw(void) : "Draws an entity if it is not drawn. Equivalent to RemoveEffects > 32."
	input DisableDraw(void) : "Undraws an entity if it is drawn. Equivalent to AddEffects > 32."
	input AddEFlags(integer) : "Adds an entity flag. NOTE: Entity flags are not the spawn flags you see in Hammer. Use AddSpawnFlags to add spawnflags."
	input RemoveEFlags(integer) : "Removes an entity flag. NOTE: Entity flags are not the spawn flags you see in Hammer. Use RemoveSpawnFlags to remove spawnflags."
	
	input SetMoveType(integer) : "Sets this entity's movetype."
	input SetCollisionGroup(integer) : "Sets this entity's collision group."
]

// Some entities do not allow the model keyvalue to be changed, therefore this is being defined per-entity instead of merging into BaseAnimating below
@BaseClass = Model
[ 
	model(studio) : "Model" :  : "The model this entity should appear as. 128-character limit."
	linedivider621(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
]

// All entities with a model have this class
@BaseClass base(BaseEntityPoint, Render) sphere(fademindist) sphere(fademaxdist) sphere(fademaxdist) = BaseAnimating
[ 
	effects(choices) : "Effect Flags" : 0 : "For configuring visual effects. If you want to combine effects, turn SmartEdit off and add the effect numbers together, i.e. 64 + 8 = 72." =
	[
		0 : "None"
		1 : "Bonemerge always, very expensive!!"
		2 : "Bright, dynamic light at entity origin"
		4 : "Dim, dynamic light at entity origin"
		8 : "No movement interpolation"
		16 : "Don't cast shadows"
		32 : "Don't draw entity (entity is fully ignored by clients, NOT server)"
		64 : "Don't receive dynamic shadows"
		128 : "Bonemerge only in PVS, better performance but prone to disappearing. Use with Bonemerge."
		256 : "Blinking glow"
		512 : "Flag parent as always animating and realign each frame"	
		// Portal 2 and later only
//      1024 : "Mark for fast reflections"
//      2048 : "No shadow depth, for use with env_cascade_light"
//      4096 : "No projected textures"
	]
	skin(integer) : "Skin" : : "Some models have multiple skins. This value selects from the index, starting with 0."
	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	SetBodyGroup(integer) : "Body Group" : : "Identical to Body Group (body), ask Valve why this is duplicated. Sets the body group index for the model, starting with 0, if available."
	texframeindex(integer) : "Texture Frame" : : "The frame number for any animated textures on this entity."		
//	hitboxset(string) : "Hitbox Set" : : "Sets the $hboxset to use for collision testing."
	LightingOrigin(target_destination) : "Lighting Origin" :  : "Select any entity (not info_lighting!) from which to sample lighting instead of the entity's origin."
//	LightingOriginHack(target_destination) : "Lighting Origin Offset" :  : "The info_lighting_relative from which to sample lighting instead of the entity's origin."
	damagefilter(target_destination) : "Damage Filter" :  : "When this entity receives damage, it will filter by this entity."
	fademindist(float) : "Start Fade Distance/Pixels" : : "Distance at which the entity starts fading. If <0, the entity will disappear instantly when end fade is hit. The value will scale appropriately if the entity is in a 3D Skybox."
	fademaxdist(float) : "End Fade Distance/Pixels" : : "Distance at which the entity ends fading. If <0, the entity won't disappear at all. The value will scale appropriately if the entity is in a 3D Skybox."
	fadescale(float) : "Fade Scale" : : "If specified in the worldspawn, or if the engine is running below DirectX 8, entities will fade out even if the fade distances above aren't specified. This value gives more control over when this happens: numbers smaller than 1 cause the entity to fade out at further distances, and greater than 1 cause it to fade out at closer distances. Using 0 turns off the forced fade altogether."	
	shadowcastdist(integer) : "Shadow Cast Distance" : : "Sets how far the entity casts dynamic shadows, in units. 0 means default distance from the shadow_control entity."
	disableshadows(boolean) : "Disable Shadows?" : 0 : "Prevent the entity from creating cheap render-to-texture/dynamic shadows."
	disablereceiveshadows(boolean) : "Disable Receiving Shadows?" : 0 : "Prevents dynamic shadows (e.g. player and prop shadows) from appearing on this entity."
	modelscale(float) : "Model Scale" : : "A multiplier for the size of the model. Negative values are accepted. Does not alter the physics collisions in most cases, however. Negative values can crash the game!"
	linedivider4(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	input skin(integer) : "Changes the model's skin to the specified index number."
	input SetBodyGroup(integer) : "Change the model's bodygroup to the specified index number."
	input Ignite(void) : "Makes the entity catch on fire indefinitely."
	input IgniteLifetime(float) : "Makes the entity catch on fire for a given amount of time."
	input IgniteNumHitboxFires(integer) : "Makes the entity catch on fire with a given number of hitbox fire particles."
	input IgniteHitboxFireScale(float) : "Makes the entity catch on fire with a given scale for hitbox fire particles."
	input BecomeRagdoll(void) : "Kills the entity and creates a client-side ragdoll from the model. Input is only passed if the model contains ragdolling, for other models phys_convert can be used instead."	
	input SetLightingOrigin(string) : "Sets the entity to use as the entity's lighting origin. Any entity can be used."
	input SetLightingOriginHack(string) : "Offsets the entity's lighting origin by their distance from an info_lighting_relative."
	input fademindist(float) : "Sets distance at which the entity starts fading. If <0, the entity will disappear instantly when end fade is hit. The value will scale appropriately if the entity is in a 3D Skybox."
	input fademaxdist(float) : "Sets distance at which the entity ends fading. If <0, the entity won't disappear at all. The value will scale appropriately if the entity is in a 3D Skybox."	
	input SetModelScale(vector) : "Multiplies the size of the model. Does not alter the physics collisions in most cases, however. Negative values are accepted, although can cause crashes. Takes two values separated by a space. The first is the target model scale. The second value is the number of seconds the change in scale will be spread over."
	input Color(color255) : "Sets an RGB color for the entity."
	input Alpha(integer) : "Sets the entity's transparency to a number from 0 (invisible) to 255 (fully visible). Requires the entity to have its Render Mode set to a number other than 0."	
	input AlternativeSorting(bool) : "Swaps the rendering order of the entity. Used to attempt to fix sorting problems when rendering, for example an object rendering in front of translucent materials."
	input SetDamageFilter(string) : "Sets a filter for this entity for when it receives damage. Pass in an empty string to clear the damage filter."	
	input DisableShadow(void) : "Allows the entity to draw a render target (dynamic) shadow."
	input EnableShadow(void) : "Prevents the entity from drawing a render target (dynamic) shadow."
	
	output OnIgnite(void) : "Fired when the entity catches fire, such as from an env_entity_igniter or the Ignite inputs."
]

// All brushes with a visible appearance have this class
@BaseClass base(BaseEntityBrush, Render) = BaseAnimatingBrush
[ 
	effects(choices) : "Effect Flags" : 0 : "For configuring visual effects. If you want to combine effects, turn SmartEdit off and add the effect numbers together, i.e. 64 + 8 = 72." =
	[
		0 : "None"
		1 : "Bonemerge always regardless of PVS, very expensive!!"
		2 : "Bright, dynamic light at entity origin"
		4 : "Dim, dynamic light at entity origin"
		8 : "No interpolation"
		16 : "Don't cast shadows"
		32 : "Don't draw entity (entity is fully ignored by clients, NOT server)"
		64 : "Don't receive dynamic shadows"
		128 : "Bonemerge only in PVS and optimise bones (may not work correctly)"
		256 : "Blinking glow"
		512 : "Flag parent as always animating and realign each frame"
		// Portal 2 and later only
//      1024 : "Mark for fast reflections"
//      2048 : "No shadow depth, for use with env_cascade_light"
//      4096 : "No projected textures"
	]
	damagefilter(target_destination) : "Damage Filter" :  : "When this entity receives damage, it will filter by this entity."
	vrad_brush_cast_shadows(choices) : "VRAD Shadows" : 0 : "Determines if this entity will cast lightmap shadows." =
	[
		0 : "Do not cast shadows"
		1 : "Cast shadows"
	]
	_minlight(string) : "Minimum Light Level" : : "The minimum level of ambient light that hits this brush."
	shadowcastdist(integer) : "Shadow Cast Distance" : : "Sets how far the entity casts dynamic shadows, in units. 0 means default distance from the shadow_control entity."
	disableshadows(boolean) : "Disable Shadows?" : 0 : "Prevent the entity from creating cheap render-to-texture/dynamic shadows."
	disablereceiveshadows(boolean) : "Disable Receiving Shadows?" : 0 : "Prevents dynamic shadows (e.g. player and prop shadows) from appearing on this entity."
	
	texframeindex(integer) : "Texture Frame" : : "The frame number for any animated textures on this entity."		
	linedivider5(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	input Color(color255) : "Sets an RGB color for the entity."
	input Alpha(integer) : "Sets the entity's transparency to a number from 0 (invisible) to 255 (fully visible). Requires the entity to have its Render Mode set to a number other than 0."	
	input AlternativeSorting(bool) : "Swaps the rendering order of the entity. Used to attempt to fix sorting problems when rendering, for example an object rendering in front of translucent materials."
	input SetDamageFilter(string) : "Sets a filter for this entity for when it receives damage. Pass in an empty string to clear the damage filter."	
	input DisableShadow(void) : "Allows the entity to draw a render target (dynamic) shadow."
	input EnableShadow(void) : "Prevents the entity from drawing a render target (dynamic) shadow."
	input EnableDamageForces(void) : "Damaging the entity applies physics forces to it."
	input DisableDamageForces(void) : "Damaging the entity does not apply physics forces to it."
]

// Stripped down version of BaseAnimating for physically-simulated objects, which do not have some keyvalues
@BaseClass base(BaseEntityPoint, Render) sphere(fademindist) sphere(fademaxdist) sphere(fademaxdist)  = BaseAnimatingPhysics
[ 
    // physics entities must have a model keyvalue
	model(studio) : "Model" :  : "The model this entity should appear as. 128-character limit."
	skin(integer) : "Skin" : 0 : "Some models have multiple skins. This value selects from the index, starting with 0."
	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, cons	rained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	body(integer) : "Body Group" : : "Sets the body group index for the model, starting with 0, if available."
//	SetBodyGroup(integer) : "(Set) Body Group" : : "Identical to Body Group (body), ask Valve why this is duplicated. Sets the body group index for the model, starting with 0, if available."
	texframeindex(integer) : "Texture Frame" : : "The frame number for any animated textures on this entity."		
	LightingOrigin(target_destination) : "Lighting Origin" :  : "Select an entity (not info_lighting!) from which to sample lighting instead of the entity's origin."
//	LightingOriginHack(target_destination) : "Lighting Origin Offset" :  : "The info_lighting_relative from which to sample lighting instead of the entity's origin."
	damagefilter(target_destination) : "Damage Filter" :  : "When this entity receives damage, it will filter by this entity."
	fademindist(float) : "Start Fade Distance/Pixels" : : "Distance at which the entity starts fading. If <0, the entity will disappear instantly when end fade is hit. The value will scale appropriately if the entity is in a 3D Skybox."
	fademaxdist(float) : "End Fade Distance/Pixels" : : "Distance at which the entity ends fading. If <0, the entity won't disappear at all. The value will scale appropriately if the entity is in a 3D Skybox."
	fadescale(float) : "Fade Scale" : 1 : "If specified in the worldspawn, or if the engine is running below DirectX 8, entities will fade out even if the fade distances above aren't specified. This value gives more control over when this happens: numbers smaller than 1 cause the entity to fade out at further distances, and greater than 1 cause it to fade out at closer distances. Using 0 turns off the forced fade altogether."	
	shadowcastdist(integer) : "Shadow Cast Distance" : : "Sets how far the entity casts dynamic shadows, in units. 0 means default distance from the shadow_control entity."
	disableshadows(boolean) : "Disable Shadows?" : 0 : "Prevent the entity from creating cheap render-to-texture/dynamic shadows."
	disablereceiveshadows(boolean) : "Disable Receiving Shadows?" : 0 : "Prevents dynamic shadows (e.g. player and prop shadows) from appearing on this entity."
	modelscale(float) : "Model Scale" : : "A multiplier for the size of the model. Negative values are accepted. Does not alter the physics collisions in most cases, however. Negative values can crash the game!"
	linedivider6(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	input skin(integer) : "Changes the model's skin to the specified index number."
	input SetBodyGroup(integer) : "Change the model's bodygroup to the specified index number."
	input Ignite(void) : "Makes the entity catch on fire indefinitely."
	input IgniteLifetime(float) : "Makes the entity catch on fire for a given amount of time."
	input IgniteNumHitboxFires(integer) : "Makes the entity catch on fire with a given number of hitbox fire particles."
	input IgniteHitboxFireScale(float) : "Makes the entity catch on fire with a given scale for hitbox fire particles."
	input SetLightingOrigin(string) : "Sets the entity to use as the entity's lighting origin. Any entity can be used."
	input SetLightingOriginHack(string) : "Offsets the entity's lighting origin by their distance from an info_lighting_relative."
	input fademindist(float) : "Sets distance at which the entity starts fading. If <0, the entity will disappear instantly when end fade is hit. The value will scale appropriately if the entity is in a 3D Skybox."
	input fademaxdist(float) : "Sets distance at which the entity ends fading. If <0, the entity won't disappear at all. The value will scale appropriately if the entity is in a 3D Skybox."	
	input SetModelScale(vector) : "Multiplies the size of the model. Does not alter the physics collisions in most cases, however. Negative values are accepted, although can cause crashes. Takes two values separated by a space. The first is the target model scale. The second value is the number of seconds the change in scale will be spread over."
	input Color(color255) : "Sets an RGB color for the entity."
	input Alpha(integer) : "Sets the entity's transparency to a number from 0 (invisible) to 255 (fully visible). Requires the entity to have its Render Mode set to a number other than 0."	
	input AlternativeSorting(bool) : "Swaps the rendering order of the entity. Used to attempt to fix sorting problems when rendering, for example an object rendering in front of translucent materials."
	input SetDamageFilter(string) : "Sets a filter for this entity for when it receives damage. Pass in an empty string to clear the damage filter."	
	input DisableShadow(void) : "Allows the entity to draw a render target (dynamic) shadow."
	input EnableShadow(void) : "Prevents the entity from drawing a render target (dynamic) shadow."
	
	output OnIgnite(void) : "Fired when the entity catches fire, such as from an env_entity_igniter or the Ignite inputs."
]

// BaseAnimatingPhysics but without the Model keyvalue, for tf_weapon_* entities
@BaseClass base(BaseEntityPoint, Render) sphere(fademindist) sphere(fademaxdist) sphere(fademaxdist)  = BaseAnimatingPhysicsWeapon
[ 
	skin(integer) : "Skin" : 0 : "Some models have multiple skins. This value selects from the index, starting with 0."
	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	body(integer) : "Body Group" : : "Sets the body group index for the model, starting with 0, if available."
//	SetBodyGroup(integer) : "(Set) Body Group" : : "Identical to Body Group (body), ask Valve why this is duplicated. Sets the body group index for the model, starting with 0, if available."
	texframeindex(integer) : "Texture Frame" : : "The frame number for any animated textures on this entity."		
	LightingOrigin(target_destination) : "Lighting Origin" :  : "Select an entity (not info_lighting!) from which to sample lighting instead of the entity's origin."
//	LightingOriginHack(target_destination) : "Lighting Origin Offset" :  : "The info_lighting_relative from which to sample lighting instead of the entity's origin."
	damagefilter(target_destination) : "Damage Filter" :  : "When this entity receives damage, it will filter by this entity."
	fademindist(float) : "Start Fade Distance/Pixels" : : "Distance at which the entity starts fading. If <0, the entity will disappear instantly when end fade is hit. The value will scale appropriately if the entity is in a 3D Skybox."
	fademaxdist(float) : "End Fade Distance/Pixels" : : "Distance at which the entity ends fading. If <0, the entity won't disappear at all. The value will scale appropriately if the entity is in a 3D Skybox."
	fadescale(float) : "Fade Scale" : 1 : "If specified in the worldspawn, or if the engine is running below DirectX 8, entities will fade out even if the fade distances above aren't specified. This value gives more control over when this happens: numbers smaller than 1 cause the entity to fade out at further distances, and greater than 1 cause it to fade out at closer distances. Using 0 turns off the forced fade altogether."	
	shadowcastdist(integer) : "Shadow Cast Distance" : : "Sets how far the entity casts dynamic shadows, in units. 0 means default distance from the shadow_control entity."
	disableshadows(boolean) : "Disable Shadows?" : 0 : "Prevent the entity from creating cheap render-to-texture/dynamic shadows."
	disablereceiveshadows(boolean) : "Disable Receiving Shadows?" : 0 : "Prevents dynamic shadows (e.g. player and prop shadows) from appearing on this entity."
	modelscale(float) : "Model Scale" : : "A multiplier for the size of the model. Negative values are accepted. Does not alter the physics collisions in most cases, however. Negative values can crash the game!"
	linedivider6(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	input skin(integer) : "Changes the model's skin to the specified index number."
	input SetBodyGroup(integer) : "Change the model's bodygroup to the specified index number."
	input Ignite(void) : "Makes the entity catch on fire indefinitely."
	input IgniteLifetime(float) : "Makes the entity catch on fire for a given amount of time."
	input IgniteNumHitboxFires(integer) : "Makes the entity catch on fire with a given number of hitbox fire particles."
	input IgniteHitboxFireScale(float) : "Makes the entity catch on fire with a given scale for hitbox fire particles."
	input SetLightingOrigin(string) : "Sets the entity to use as the entity's lighting origin. Any entity can be used."
	input SetLightingOriginHack(string) : "Offsets the entity's lighting origin by their distance from an info_lighting_relative."
	input fademindist(float) : "Sets distance at which the entity starts fading. If <0, the entity will disappear instantly when end fade is hit. The value will scale appropriately if the entity is in a 3D Skybox."
	input fademaxdist(float) : "Sets distance at which the entity ends fading. If <0, the entity won't disappear at all. The value will scale appropriately if the entity is in a 3D Skybox."	
	input SetModelScale(vector) : "Multiplies the size of the model. Does not alter the physics collisions in most cases, however. Negative values are accepted, although can cause crashes. Takes two values separated by a space. The first is the target model scale. The second value is the number of seconds the change in scale will be spread over."
	input Color(color255) : "Sets an RGB color for the entity."
	input Alpha(integer) : "Sets the entity's transparency to a number from 0 (invisible) to 255 (fully visible). Requires the entity to have its Render Mode set to a number other than 0."	
	input AlternativeSorting(bool) : "Swaps the rendering order of the entity. Used to attempt to fix sorting problems when rendering, for example an object rendering in front of translucent materials."
	input SetDamageFilter(string) : "Sets a filter for this entity for when it receives damage. Pass in an empty string to clear the damage filter."	
	input DisableShadow(void) : "Allows the entity to draw a render target (dynamic) shadow."
	input EnableShadow(void) : "Prevents the entity from drawing a render target (dynamic) shadow."
	
	output OnIgnite(void) : "Fired when the entity catches fire, such as from an env_entity_igniter or the Ignite inputs."
]

@BaseClass = EnableDisable
[
	StartDisabled(boolean) : "Start Disabled?" : 0

	input Enable(void) : "Enable this entity."
	input Disable(void) : "Disable this entity."
]

// Some entites have Toggle only but not EnableDisable for some reason
@BaseClass = Toggle
[
	input Toggle(void) : "Toggle the enabled/disabled status of this entity."
]

@BaseClass = BaseFilter
[
	Negated(choices) : "Filter mode" : "0" : "If set to Allow, only entities who match the criteria will pass the filter. "+
		"If set to Disallow, only entities who do NOT match the criteria will pass the filter." =
	[
		0 : "Allow entities that match criteria"
		1 : "Disallow entities that match criteria"
	]

	input TestActivator(void) : "Test the activator against the filter and fires OnPass or OnFail output."

	output OnPass(void) : "Fired in response to TestActivator input if the activator passes the filter."
	output OnFail(void) : "Fired in response to TestActivator input if the activator fails to pass the filter."
]

@BaseClass base(BaseEntityBrush) = Trigger
[
	StartDisabled(boolean) : "Start Disabled?" : 0
	
	spawnflags(flags) = 
	[
		1: "Clients/Players/Bots" : 1
		2: "NPCs" : 0
		4: "Pushables": 0
		8: "Physics Objects" : 0
		16: "Only player ally NPCs" : 0
		32: "Only clients in vehicles" : 0
		64: "Everything (not including physics debris)" : 0
		512: "Only clients *not* in vehicles" : 0
		1024: "Physics debris" : 0
		2048: "Only NPCs in vehicles (respects player ally flag)" : 0
		4096: "Disallow Bots" : 0
	]

	filtername(filterclass) : "Filter Name" : : "A filter entity to test potential activators against."

	input Enable(void) : "Enable this trigger."
	input Disable(void) : "Disable this trigger, some trigger entites may also fire OnEndTouch when disabled."
	input Toggle(void) : "Toggles this trigger between enabled and disabled states."
    input TouchTest(void) : "Triggers either the OnTouching or OnNotTouching outputs for whether anything is touching this entity."
    input StartTouch(void) : "Fires the OnStartTouch output. If called by an entity inside the trigger, the OnStartTouch will be fired for them as the activator. Note that this input is passed even if the player is being treated as 'not' touching the trigger while inside it."
    input EndTouch(void) : "Fires the OnEndTouch output. If called by an entity inside the trigger, the OnEndTouch will be fired for them as the activator. Note that this input is passed even if the player is being treated as 'not' touching the trigger while outside it."

	output OnTrigger(void) : "Fired whenever the trigger is activated."
	output OnStartTouch(void) : "Fired when an entity starts touching this trigger. The touching entity must pass this trigger's filters to cause this output to fire."
	output OnStartTouchAll(void) : "Fired when an entity starts touching this trigger, and no other entities are touching it. Only entities that passed this trigger's filters are considered."
	output OnEndTouch(void) : "Fired when an entity stops touching this trigger. Only entities that passed this trigger's filters will cause this output to fire."
	output OnEndTouchAll(void) : "Fires when an entity stops touching this trigger, and no other entities are touching it. Only entities that passed this trigger's filters are considered."
    output OnTouching(void) : "Fired when the TouchTest input is called. Does not call activators."
    output OnNotTouching(void) : "Fired when the TouchTest input is called. Does not call activators."
]

// All breakables have this
@BaseClass sphere(exploderadius) = Breakable
[
	ExplodeDamage(float) : "Explosion Damage" : 0 : "If non-zero, when this entity breaks it will create an explosion that causes the specified amount of damage. See also 'Explosion Radius'."
	ExplodeRadius(float) : "Explosion Radius" : 0 : "If non-zero, when this entity breaks it will create an explosion with a radius of the specified amount. See also 'Explosion Damage'."
	PerformanceMode(choices) : "Performance Mode" : 0 : "Used to limit the amount of gibs produced when this entity breaks, for performance reasons." =
	[
		0 : "Normal"
		1 : "No Gibs"
		2 : "Full Gibs on All Platforms"
		3 : "Reduced gibs"
	]
	pressuredelay(float) : "Pressure Delay" : 0 : "Delay, in seconds, after 'broken' by pressure before breaking apart (allows for sound to play before breaking apart)."
	minhealthdmg(integer) : "Minimum Damage to Hurt" : 0 : "The entity will ignore any damage events if the damage is less than this amount."	
	health(integer) : "Health" : 0 : "Number of points of damage to take before breaking. 0 means don't break."
	physdamagescale(float) : "Physics Impact Damage Scale" : "1.0" : "Scales damage energy when this object is hit by a physics object. Set to 1.0 for materials as strong as flesh, smaller numbers indicate stronger materials."
	linedivider8(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	input Break(void) : "Breaks the breakable."
	input SetHealth(integer) : "Sets a new value for the breakable's 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."
	input SetMass(float) : "Set mass of this object."
	
    // func_physbox and prop_physics only	
//	input EnablePhyscannonPickup(void) : "Makes the breakable able to picked up by the physcannon."
//	input DisablePhyscannonPickup(void) : "Makes the breakable not able to picked up by the physcannon."
	
	output OnBreak(void) : "Fired when this breakable breaks."
	output OnHealthChanged(float) : "Fired when the health of this breakable changes, passing the new value of health as a percentage of max health, from [0..1]."

    // func_physbox and prop_physics only	
	//output OnPhysCannonDetach(void) : "Fired when the physcannon has ripped this breakable off of the wall. Only fired if ACT_PHYSCANNON_DETACH is defined in the model this breakable is using."
	//output OnPhysCannonAnimatePreStarted(void) : "Fired when this prop starts playing the Pre physcannon-pull activity, caused by the player trying to grab this prop with the physcannon. Only fired if the ACT_PHYSCANNON_ANIMATE_PRE activity is defined in the model this breakable is using."
	//output OnPhysCannonAnimatePullStarted(void) : "Fired when this prop starts playing the physcannon-pull activity, caused by the player trying to grab this prop with the physcannon. Only fired if the ACT_PHYSCANNON_ANIMATE activity is defined in the model this breakable is using. If the prop has Pre pull anim, this will be fired after the Pre anim has finished playing."
	//output OnPhysCannonPullAnimFinished(void) : "Fired when this prop has finished playing the physcannon-pull activity, caused by the player trying to grab this prop with the physcannon. Only fired if the ACT_PHYSCANNON_ANIMATE activity is defined in the model this breakable is using. If the prop has Pre & Post pull anims, this will be fired after the Post anim has finished playing."
	//output OnPhysCannonAnimatePostStarted(void) : "Fired when this prop starts playing the Post physcannon-pull activity. Only fired if the ACT_PHYSCANNON_ANIMATE_POST activity is defined in the model this breakable is using."
]

@BaseClass base(BaseAnimatingBrush, Breakable) sphere(exploderadius) = BreakableBrush
[
	propdata(choices) : "Prop Data" : 0 : "Set to the best approximation of the size and material of this entity's brushes. If set, it will override this entity's health and damage taken from various weapons. See the propdata.txt file in the scripts directory of your MOD to get a detailed list of what each entry specifies." =
	[
		0 : "None"
		1 : "Wooden.Tiny"
		2 : "Wooden.Small"
		3 : "Wooden.Medium"
		4 : "Wooden.Large"
		5 : "Wooden.Huge"
		6 : "Metal.Small"
		7 : "Metal.Medium"
		8 : "Metal.Large"
		9 : "Cardboard.Small"
		10 : "Cardboard.Medium"
		11 : "Cardboard.Large"
		12 : "Stone.Small"
		13 : "Stone.Medium"
		14 : "Stone.Large"
		15 : "Stone.Huge"
		16 : "Glass.Small"
		17 : "Plastic.Small"
		18 : "Plastic.Medium"
		19 : "Plastic.Large"
		20 : "Pottery.Small"
		21 : "Pottery.Medium"
		22 : "Pottery.Large"
		23 : "Pottery.Huge"
		24 : "Glass.Window"
	]
	material(choices) :"Material Type" : 0 : "Set to the material type of the brush. Used to decide what sounds to make when damaged, and what gibs to produce when broken." =
	[
		0: "Glass"
		1: "Wood"
		2: "Metal"		
		3: "Flesh"
		4: "CinderBlock"
		5: "Ceiling Tile"
		6: "Computer"
		7: "Unbreakable Glass"
		8: "Rocks"
	    9: "Web"
		10: "None"
	]
	explosion(choices) : "Gibs Direction" : 0 : "Used to decide which direction to throw gibs when broken." =
	[
		0: "Random"
		1: "Relative to Attack"
		2: "Use Precise Gib Dir"
	]
	gibdir(angle) : "Precise Gib Direction" : "0 0 0" : "Specifies the direction to throw gibs when this breakable breaks. Be sure to select Use Precise Gib Dir in the Gibs Direction field!"
	explodemagnitude(integer) : "Explode Magnitude" : 0 : "If non-zero, when this entity breaks it will create an explosion that causes the specified amount of damage."

	nodamageforces(boolean) : "Damaging it Doesn't Push It" : 0 : "Used to determine whether or not damage should cause the brush to move."
	gibmodel(string) : "Gib Model" :  : "Specify a custom gib model to break into, overriding the 'Material Type'."
	spawnobject(choices) : "Spawn On Break" : 0 : "When broken, an entity of the selected type will be created. Hardcoded values." =
	[
		1:	"item_battery"
		2:	"item_healthkit"
		3:	"item_ammo_pistol"
		4:	"item_ammo_pistol_large"
		5:	"item_ammo_smg1"
		6:	"item_ammo_smg1_large"
		7:	"item_ammo_ar2"
		8:	"item_ammo_ar2_large"
		9:	"item_box_buckshot"
		13:	"item_smg1_grenade"
		16:	"weapon_stunstick"
		18:	"weapon_ar2"
		21:	"weapon_smg1"
		23:	"weapon_slam"
		24:	"weapon_shotgun"	
        26: "item_dynamic_resupply"		
	]
	
	
	linedivider9(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	spawnflags(flags) =
	[
		1 : "Only Break on Trigger" : 0
		2 : "Break on Touch" : 0
		4 : "Break on Pressure" : 0
		512: "Break immediately on Physics" : 0
		1024: "Don't take physics damage" : 0
		2048: "Don't allow bullet penetration": 0
	]
]

// Not defining BaseEntity/BaseAnimating here as some entities using this do not have some of BaseAnimating keyvalues/inputs/outputs, and don't want the class to be inserted twice
@BaseClass base(Breakable) sphere(exploderadius) = BreakableProp
[
	spawnflags(flags) =
	[
		16 : "Break on Touch" : 0
		32 : "Break on Pressure" : 0
	]
	
	output OnTakeDamage(void) : "Fired each time this breakable takes any damage."
		
	input EnableDamageForces(void) : "Damaging the entity applies physics forces to it."
	input DisableDamageForces(void) : "Damaging the entity does *not* apply physics forces to it."
]

// prop_dynamic base, have to define it here because some entities (such as dynamic_prop) precede prop_dynamic alphabetically and therefore cannot inherit from prop_dynamic
@BaseClass base(Model, BaseAnimating, BreakableProp, EnableDisable) = prop_dynamic_base
[
	DefaultAnim(string) : "Default Animation" :  : "The name of the idle animation that this prop will revert to whenever it finishes a random or forced animation."
	RandomAnimation(boolean) : "Randomly Animate?" : 0 : "If set, this prop will randomly choose and play animations, based upon the times specified in 'Min/Max Random Anim Time'. Inbetween the random animations, it will revert to playing the 'Default Animation'."
	MinAnimTime(float) : "Min Random Anim Time" : "5" : "Minimum time between random animations."
	MaxAnimTime(float) : "Max Random Anim Time" : "10" : "Maximum time between random animations."
	
	DisableBoneFollowers(boolean) : "Disable Bone Followers?" : 0 : "If set, this prop won't generate phys_bone_followers."
	
	linedivider10(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	spawnflags(flags) =
	[
		64 : "Use Hitboxes for Renderbox" : 0
		256 : "Start with collision disabled" : 0
	]
	
	input SetAnimation(string) : "Force the prop to play an animation. The parameter should be the name of the animation."
	input SetDefaultAnimation(string) : "Set the Default Animation to the one specified in the parameter."
	input SetPlaybackRate(float) : "Set the playback rate for the animation."
	input TurnOn(void) : "Make the prop visible."
	input TurnOff(void) : "Make the prop invisible."
	input EnableCollision(void) : "Enable collision on the prop."
	input DisableCollision(void) : "Disable collision on the prop."

	output OnAnimationBegun(void) : "Fired whenever a new animation has begun playing."
	output OnAnimationDone(void) : "Fired whenever an animation is complete."
]


@BaseClass base(BaseAnimating, Model) color(0 200 200) = BaseNPC
[
	target(target_destination) : "Target Path Corner" : : "If set, the name of a path_corner entity that this NPC will move to, after spawning. Must be within 576 units from the NPC."
	health(integer): "Health" : : "Overrides the NPC's default health. Cannot be higher than Max Health."
	max_health(integer): "Max Health" : : "Overrides the NPC's max health. Health cannot exceed this amount."
	additionalequipment(string) : "Weapon Held" : : "Gives the NPC a weapon. NPCs may attack oddly or not attack if they don't know how to use a particular weapon."
	relationship(string) : "Relationship" : : "Changes whether this NPC likes or dislikes certain others. Format is: <string|targetname or classname> <string|disposition> <integer|rank>. Values for disposition are: D_HT (Hate), D_FR (Fear), D_LI (Like), D_NU, (Neutral)."
	squadname(String) : "Squad Name" : : "NPCs that are in the same squad will share information about enemies, and will take turns attacking and covering each other."
	sleepstate(choices) : "Sleep State" : 0 : "Holds the NPC in stasis until specified condition. See also 'Wake Radius' and 'Wake Squad'." =
	[
		0 : "None"
		1 : "Waiting for threat"
		2 : "Waiting for PVS"
		3 : "Waiting for input, ignore PVS"
		4 : "Auto PVS"
		5 : "Auto PVS after PVS"
	]

	wakeradius(float) : "Wake Radius" : 0 : "Auto-wake if player is within this distance, in Hammer units."
	wakesquad(boolean) : "Wake Squad" : 0 : "If yes, wake all of the NPCs squadmates if the NPC is woken."
	
	ignoreunseenenemies(boolean) : "Ignore unseen enemies?" : 0 : "Prefer visible enemies, regardless of distance or relationship priority."
	
	hintgroup(String) : "Hint Group" :  : "Hint groups are used by NPCs to restrict their hint-node searching to a subset of the map's hint nodes. Only hint nodes with matching hint group names will be considered by this NPC."
	hintlimiting(boolean) : "Hint Limit Nav" : 0 : "Limits NPC to using specified hint group for navigation requests, but does not limit local navigation."
	
	enemyfilter(target_destination) : "Enemy Filter" :  : "Filter by which to filter potential enemies."
	physdamagescale(float) : "Physics Impact Damage Scale" : "1.0" : "Scales damage energy when this NPC is hit by a physics object. With a value of 0 the NPC will take no damage from physics."
	ExpressionOverride(string) : "Enter a VCD file to override facial expressions on this NPC."
	
	DontUseSpeechSemaphore(choices) : "Don't Use Speech Semaphore?" : 0 : "Friendly NPCs are not allowed to speak if another friendly NPC is speaking. In some cases we don't want speaking NPCs to prevent other NPCs from speaking (for instance, if there is a friendly NPC speaking for a long time on a monitor). To make this NPC not prevent other NPCs from talking, make it not grab the semaphore when it speaks." =
	[
		0 : "No (Use speech semaphore)"
		1 : "Yes (Don't use speech semaphore)"
	]

	velocity(vector) : "Local Velocity" :  : "Velocity generated by the entity, can cause strange behavior if changed with AddOutput."
	basevelocity(vector) : "Base Velocity" :  : "Velocity to start with on spawn. Can be changed with AddOutput, where it will be immediately added."
	avelocity(vector) : "Angular Velocity" :  : "Angular velocity to start with on spawn. Can be changed with AddOutput, where it will be immediately added."
	waterlevel(float) : "Water Level" :  : "Current water level of the entity, can cause strange behavior if changed with AddOutput."
	
	linedivider7(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	spawnflags(Flags) = 
	[
		1 : "Wait Till Seen" : 0
		2 : "Gag (No idle sounds until angry)" : 0
		4 : "Fall to ground (unchecked means teleport to ground)" : 1
		8 : "Drop Healthkit" : 0
		16 : "Efficient - Don't acquire enemies or avoid obstacles" : 0
		128: "Wait For Script" : 0
		256: "Long Visibility/Shoot" : 0
		512: "Fade Corpse" : 1
		1024: "Think outside PVS, bad for performance" : 0
		2048: "Template NPC (used by npc_maker, will not spawn)" : 0
		4096: "Do alternate collision for this NPC (player avoidance)" : 0
		8192: "Don't drop weapons" : 0
		16384 : "Ignore player push (dont give way to player)" : 0
	]
	
	input SetHealth(integer) : "Set this entity's health."
	input SetMaxHealth(integer) : "Set this entity's maximum health."
	input AddHealth(integer) : "Add health to this entity."
	input RemoveHealth(integer) : "Remove health from this entity."
	input SetRelationship(string) : "Changes this entity's relationship with another entity or class. Format: <entity name/classname> <D_HT/D_FR/D_LI/D_NU> <priority>"
	input SetEnemyFilter(string) : "Set a filter by which to filter potential enemies."
	input BeginRappel(void) : "Tells NPC to begin rappelling. May not do anything."
	input SetSquad(string) : "Changes the name of this NPC's squad. Leaving the parameter blank will remove the NPC from any existing squad."
	input Wake(void) : "Wakes up the NPC if it is sleeping."
	input UpdateEnemyMemory(string) : "Update (or create) this NPC's memory of of the given entity."
	input ForgetEntity(string) : "Clears out the NPC's knowledge of a named entity."
	input IgnoreDangerSounds(float) : "Ignore danger sounds for the specified number of seconds."
	input Break(void) : "Makes the NPC die and disappear."
	input physdamagescale(float) : "Sets the value that scales damage energy when this NPC is hit by a physics object."
	input StartScripting(void) : "Puts the NPC into a 'scripted' state. It will ignore a variety of stimuli, such as +use, danger sounds, and idle speech."
	input StopScripting(void) : "Puts the NPC into their normal state again."
	input GagEnable(void) : "Prevents the NPC from making any vocalized sounds or speech, unless they are in a choreographed scene."
	input GagDisable(void) : "Allow the NPC to make vocalizations again."
	input InsideTransition(void) : "Tells the NPC to stop any choreography (but not scripted speech) its a part of. Usually this is only done by a trigger_changelevel when a player steps inside it, and the NPC is inside an associated trigger_transition."
	input HolsterWeapon(void) : "Force the NPC to holster their weapon. Ignored if the NPC is scripting, if the NPC's weapon is already holstered, or if the NPC doesn't use weapons."
	input HolsterAndDestroyWeapon(void) : "Identical to HolsterWeapon, except the weapon is destroyed once it has been holstered and concealed."
	input UnholsterWeapon(void) : "Force the NPC to draw their weapon. Ignored if the NPC is scripting, if the NPC's weapon is already drawn, or if the NPC doesn't use weapons."
	input ForceInteractionWithNPC(string) : "Force the NPC to use a dynamic interaction with another NPC. Syntax is <targetname> <dynamic interaction>."
	input SetExpressionOverride(string) : "Set a VCD file to override facial expressions on this NPC."

	output OnHealthBelow90Percent(void) : "Sent when the entity's health drops below 90 percent."
	output OnHealthBelow80Percent(void) : "Sent when the entity's health drops below 80 percent."
	output OnHealthBelow70Percent(void) : "Sent when the entity's health drops below 70 percent."
	output OnHealthBelow60Percent(void) : "Sent when the entity's health drops below 60 percent."
	output OnHealthBelow50Percent(void) : "Sent when the entity's health drops below 50 percent."
	output OnHealthBelow40Percent(void) : "Sent when the entity's health drops below 40 percent."
	output OnHealthBelow30Percent(void) : "Sent when the entity's health drops below 30 percent."
	output OnHealthBelow20Percent(void) : "Sent when the entity's health drops below 20 percent."
	output OnHealthBelow10Percent(void) : "Sent when the entity's health drops below 10 percent."
	output OnKilled(void) : "Sent when the entity is killed."
	output OnDamaged(void) : "Fired when this NPC takes damage."
	output OnDamagedByPlayer(void) : "Fired when this NPC is hurt by a player."
	output OnDamagedByPlayerSquad(void) : "Fired when this NPC is hurt by a player OR by one of the player's squadmates."
	output OnHalfHealth(void) : "Fired when this NPC reaches half of its maximum health."
	output OnDeath(void) : "Fired when this NPC is killed." 
	output OnHearWorld(void) : "Fired when this NPC hears a sound (other than combat or the player)."
	output OnHearPlayer(void) : "Fired when this NPC hears the player."
	output OnHearCombat(void) : "Fired when this NPC hears combat sounds."
	output OnFoundEnemy(string) : "Fired when this NPC establishes line of sight to its enemy (outputs entity)."
	output OnLostEnemyLOS(void) : "Fired when this NPC loses line of sight to its enemy."
	output OnLostEnemy(void) : "Fired when this NPC loses its enemy. Usually due to the enemy being killed/removed, or because this NPC has selected a newer, more dangerous enemy."
	output OnFoundPlayer(string) : "Fired when this NPC establishes line of sight to its enemy, and that enemy is a player (outputs player entity)."
	output OnLostPlayerLOS(void) : "Fired when this NPC loses line of sight to its enemy, and that enemy is a player."
	output OnLostPlayer(void) : "Fired when this NPC loses its enemy, and that enemy was a player. Usually due to the enemy being killed/removed, or because this NPC has selected a newer, more dangerous enemy."
	output OnDenyCommanderUse(void) : "Fired when this NPC has refused to join the player's squad."
	output OnSleep(void) : "Fired when this NPC enters a sleep state."
	output OnWake(void) : "Fired when this NPC comes out of a sleep state."
	output OnForcedInteractionStarted(void) : "Fired when the NPC starts a forced interaction."
	output OnForcedInteractionAborted(void) : "Fired when the NPC aborts a forced interaction for some reason (target NPC died, couldn't be pathed to, etc)."
	output OnForcedInteractionFinished(void) : "NPCs in actbusies can no longer perform dynamic interactions."
]

// shooter base, have to define it here because some entities (such as env_rotorshooter) precede env_shooter alphabetically and therefore cannot inherit from it
@BaseClass base(BaseEntityPoint, Render) = env_shooter_base
[
	angles(angle) : "Gib Direction (Pitch Yaw Roll)" : "0 0 0" : "The direction the gibs will fly."
	m_iGibs(integer) : "Number of Gibs" : 3 : "Total number of gibs to shoot each time it's activated."
	delay(string) : "Delay between shots" : "0" : "Delay (in seconds) between shooting each gib. If 0, all gibs shoot at once."
	scale(float) : "Gib Scale" : "1" : "Multiplies the size of the gib models. Physics will not be scaled up."
	gibanglevelocity(string) : "Max angular velocity" : "0" : "How fast (degrees/sec) the gib pieces should spin. They will spin on x and y axis at between 10% and 100% of this speed."
	gibgravityscale(float) : "Gib gravity scale" : "1" : "Only works for 'Point' type gibs. This field allows you to scale gravity so that gibs fall faster, slower, or not at all."
	m_flVelocity(integer) : "Gib Velocity" : 200 : "Speed of the fired gibs."
	m_flVariance(string) : "Course Variance" : "0.15" : "How much variance in the direction gibs are fired."
	m_flGibLife(string) : "Gib Life" : "4" : "Time in seconds for gibs to live +/- 5%"
	lightingorigin(target_destination) : "Lighting Origin" :  : "Select an entity to specify a location to sample lighting from for all gibs spawned by this shooter, instead of their own origins."

	shootmodel(studio) : "Model" :  : "Thing to shoot out.  Can be a .mdl or a .vmt."
	shootsounds(choices) : "Material Sound" : -1 =
	[
		-1: "None"
		0: "Glass"
		1: "Wood"
		2: "Metal"
		3: "Flesh"
		4: "Concrete"  
	]
	simulation(choices) : "Simulate" : 0 =
	[
		0: "Point"
		1: "Physics"
		2: "Ragdoll"
	]
	nogibshadows(boolean) : "Disable Shadows on Gibs" : 0

	skin(integer) : "Gib Skin" : 0 : "Some models have multiple versions of their textures, called skins. Set this to a number other than 0 to use that skin on all gibs produced by this shooter."
	linedivider11(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	spawnflags(flags) =
	[
		1 : "Repeatable"  : 1
		2 : "Ignited (does not work with ragdolls)" : 0
		4 : "Strict remove after lifetime (needed if 'Ignited' is checked)" : 1
	]
]

// vehicles :blockcivilianbastard:
@BaseClass base(BaseAnimatingPhysics) = BaseVehicle
[
	vehiclescript(string) : "Vehicle Script File" : "scripts/vehicles/jeep_test.txt"
	actionScale(float) : "Scale of action input / framerate" : "1"
	
	spawnflags(flags) =
	[
		1 : "Always Think (Run physics every frame)" : 1
	]

	input Action(float) : "Set the speed of the action animation"
	input Steer(float) : "Steer the vehicle +/-1"
	input Throttle(float) : "Throttle +/-1"
	
	input HandBrakeOn(void) : "Turns the handbrake on"
	input HandBrakeOff(void): "Releases the handbrake"
]

@BaseClass base(BaseVehicle) = BaseDriveableVehicle
[
	VehicleLocked(boolean) : "Start Locked?" : 0
	
	EnableGun(boolean) : "Has Gun?" : 0 : "Whether the vehicle's gun is enabled or disabled."
	
	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 EnableGun(bool) : "Enables or disables the gun and associated crosshair."

	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]"
]

@BaseClass base(BaseAnimatingBrush) = Door
[
	chainstodoor(string) : "Linked Door" : : "Passes the door's +use inputs and touch events onto a different door, so it also is activated."
	speed(integer) : "Speed" : 100 : "The speed at which the door moves."
	wait(integer) : "Delay Before Reset (-1 stay)" : -1 : "Amount of time, in seconds, after the door has opened before it closes. Once it has closed, it can be used again. If the value is set to -1, the door never closes itself."
	lip(integer) : "Lip" : 0 : "The amount, in units, of the door to leave sticking out of the wall it recedes into when pressed. Negative values make the door recede even further into the wall."
	dmg(integer) : "Blocking Damage" : 0 : "Amount of damage done to entities that block the movement of this door, per frame."
	health(integer) : "Door Health" : : "The health of the door (allows someone to shoot it open). 0 means invincible."
	
	noise1(sound) : "Start Sound" : : "Sound to play when the door starts moving."
	noise2(sound) : "Stop Sound" : : "Sound to play when the door stops moving."
	startclosesound(sound) : "Start Close Sound" : : "Sound to play when the door starts closing."
	closesound(sound) : "Stop Close Sound" : : "Sound to play when the door stops closing."
	locked_sound(sound) : "Locked Sound" : : "Sound played when the player tries to use the door, and fails because it's locked."
	unlocked_sound(sound) : "Unlocked Sound" : : "Sound played when the door is unlocked and used."
	loopmovesound(boolean) : "Loop Moving Sound?" : 0 : "If set to true, the door's 'Start Sound' will be continually looped until the door finishes moving."
	
	spawnpos(choices) : "Spawn Position?" : 0 =
	[
		0 : "Closed"
		1 : "Open"
	]
	forceclosed(boolean) : "Force Closed?" : 0 : "If set, this door will close no matter what. Useful for doors that have to close even if the player tries to block them with objects."
	ignoredebris(boolean) : "Ignore Debris?" : 0 : "If set this will change the door's collision group to one that ignore collisions with debris objects (note that this is not compatible with the non-solid-to-player spawnflag)."
	
	linedivider13(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	spawnflags(flags) =
	[
        1: "Starts Open - Obsolete. Door behaves more like the doors in Half-Life. Some outputs don't work" : 0
		4: "Non-Solid to Player -  Not compatible with Ignore Debris" : 0
		8: "Passable -  Door is solid to nothing at all" : 0
	    32: "Toggleable - The door is given an input to change this door between open and shut" : 0
		256:"Use Opens - The door will open if it receives a +USE input from a player. Useless in TF2 as +USE is hidden in obscurity" : 0
		512: "NPCs can't Open - NPCs can't open this door" : 0
		1024: "Touch Opens - When a player or NPC touches the door, it will count as an attempt to open it" : 0
		2048: "Starts Locked - This door spawns locked and cannot be opened by the player or NPCs (but buttons can still trigger it)" : 0
		4096:  "Door Silent -  This door makes no noise" : 0
		65536: "New +USE rules - Allow +USE only when when the door is closed/closing or is open/opening and can be manually closed" : 0
	]

	output OnClose(void) : "Fired when the door starts closing."
	output OnOpen(void) : "Fired when the door starts opening."
	output OnFullyOpen(void) : "Fired when the door reaches the fully open position. Reversed if 'Start Open' flag is set."
	output OnFullyClosed(void) : "Fired when the door reaches the fully closed position. Reversed if 'Start Open' flag is set."
	output OnBlockedClosing(void) : "Fired when the door is blocked while closing."
	output OnBlockedOpening(void) : "Fired when the door is blocked while opening."
	output OnUnblockedClosing(void) : "Fired when the door is unblocked while closing."
	output OnUnblockedOpening(void) : "Fired when the door is unblocked while opening."
	output OnLockedUse(void) : "Fired when the player uses the door, but it is locked."

	input Open(void) : "Open the door, if it is not fully open."
	input Close(void) : "Close the door, if it is not fully closed."
	input Toggle(void) : "Toggle the door between open and closed."
	input Lock(void) : "Lock the door."
	input Unlock(void) : "Unlock the door."
	input SetSpeed(float) : "Set the door speed."
	input SetToggleState(bool) : "Set the toggle state of the door to currently open or closed."
]

@BaseClass base(BaseAnimatingBrush) = BaseTrain
[
	target(target_destination) : "First Stop Target" :  : "The name of the first path_track in the train's path. The train will spawn at this path_track. It will also turn to face direction indicated by the 'Orientation Type' setting."
	startspeed(integer) : "Max Speed (units / second)" : 100 : "The maximum speed that this train can move. Any speeds applied to this train, such as by path_tracks or SetSpeed inputs, will be clipped to this maximum value."
	speed(integer) : "Initial Speed (units / second)" : 0 : "The speed that the train will move at after it spawns, 0 = stopped."
	
	velocitytype(choices) : "Change Velocity..." : 0 : "The method through which this train changes its velocity as it moves along the path." =
	[
		0 : "Instantaneously"
		1 : "Linear blend"
		2 : "Ease in/ease out"
	]
	orientationtype(choices) : "Change Angles..." : 1 : "The method through which this train changes its orientation as it moves along the path." =
	[
		0 : "Never (fixed orientation)"
		1 : "Near path_tracks"
		2 : "Linear blend"
		3 : "Ease in/ease out"
	]
	
	wheels(integer) : "Distance Between the Wheels" : 50 : "Used for turning and stopping. Higher values will result in smoother turns."
	height(integer) : "Height above track" : 0 : "The height above the track that this train moves."
	bank(string) : "Bank Angle on Turns" : "0" : "The angle at which the train will 'bank' or tilt when approaching a turn. Use positive or negative angle numbers close to 0 (ie. between -5 and +5, depending on left or right) to achieve realistic tilt angles."
	dmg(integer) : "Damage on Crush" : 0 : "The amount of damage this train does to entities that block it."

	MoveSound(sound) : "Move Sound" :  : "A sound that is played (and looped) while the train is moving."
	MovePingSound(sound) : "Move Ping Sound" :  : "A sound that is played more frequently as the train speeds up."
	StartSound(sound) : "Start Sound" :  : "A sound played when the train starts moving."
	StopSound(sound) : "Stop Sound" :  : "A sound played when the train stops moving."
	volume(integer) : "Volume (10 = loudest)" : 10 : "Volume of the sound when the train is moving."
	MoveSoundMinPitch(integer) : "Min pitch (1-255, > 100 = higher)" : 60 : "The sound pitch value that the train will approach as it comes to a stop."
	MoveSoundMaxPitch(integer) : "Max pitch (1-255, > 100 = higher)" : 200 : "The sound pitch value that the train will approach as it approaches its max speed (or 1000 units/second if the 'Use max speed for pitch shifting move sound' flag is not set)."
	MoveSoundMinTime(float) : "Min move sound interval" : 0 : "Minimum interval at which to play the move ping sound."
	MoveSoundMaxTime(float) : "Max move sound interval" : 0 : "Maximum interval at which to play the move ping sound."

	ManualSpeedChanges(choices) : "Manual Train Speed?" : 0 : "Train Speed is controlled through I/O only, and handles acceleration/deceleration times." =
	[
		0 : "Off"
		1 : "On"
	]
	ManualAccelSpeed(float) : "Manual Accel Speed" : 0 : "Units per second to accelerate to target speed."
	ManualDecelSpeed(float) : "Manual Decel Speed" : 0 : "Units per second to decelerate to target speed."
	
	linedivider14(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	spawnflags(flags) =
	[
		1 : "No Pitch (X-rot)" : 0
		2 : "No User Control" : 0
		8 : "Passable - No collision to anything" : 0
		16 : "Always Fixed Orientation" : 0
		128 : "Rideable Train" : 1
		256 : "Use max speed for pitch shifting move sound" : 0
		512 : "Not blockable by players" : 1
	]	
	
	input SetSpeed(float) : "Set the speed of the train, as a ratio of max speed [0, 1]"
	input SetSpeedDir(float) : "Set the speed of the train, as a ratio of max speed. Negative values reverse the direction [-1, 1]"
	input SetSpeedReal(float) : "Set the speed of the train. Must be a positive value from 0 to max speed."
	input SetSpeedDirAccel(float) : "Accel/Decel to the specified speed, as a ratio of max speed. Negative values reverse the direction [-1, 1]"
	input SetSpeedForwardModifier(float) : "Applies the given modifier to all forward speeds. [0, 1]"
	input TeleportToPathTrack(string) : "Teleport train to the designated path_track."
	input Stop(void) : "Stop the train."
	input StartForward(void) : "Start the train moving forward."
	input StartBackward(void) : "Start the train moving backward."
	input Resume(void) : "Resume the train moving in the current direction after it was stopped via the 'Stop' or 'Toggle' input."
	input Reverse(void) : "Reverse the direction of the train."
	input Toggle(void) : "Toggle the train between start and stop."
	
	output OnStart(void) : "Fired when the train starts moving in either direction."
	output OnNextPoint(void) : "Fires continuously when the train is moving to its next destination."
]

// used by phys_ entities
@BaseClass base(BaseEntityPoint) = TwoObjectPhysics
[
    attach1(target_destination) : "Entity 1" : ""
    attach2(target_destination) : "Entity 2" : ""
	constraintsystem(target_destination) : "Constraint System Manager" :  : "The name of a phys_constraintsystem that this constraint should be a part of. All constraints on a set of entities should be placed in the same system, or they will fight each other during simulation."

	forcelimit(float) : "Force Limit to Break (lbs)" : "0" : "The amount of force an impact must apply to the constraint to break it. A way of calculating this is to set it to the mass of an object that would break this constraint if it were resting on the constrainted objects."
	torquelimit(float) : "Torque Limit to Break (lbs * distance)" : "0" : "The amount of torque required to break the constraint. A way of calculating this is to multiply any reference mass by the resting distance (from the center of mass of the object) needed to break the constraint."
	breaksound(sound) : "Play Sound on Break" :  : "A sound played when the constraint is broken."
	teleportfollowdistance(float) : "Follow teleport distance" : "0" : "If one object teleports more than this many units away it will cause the other constrained object to teleport to an appropriate relative position."
	
	linedivider15(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	spawnflags(flags) =
	[
		1: "No Collision until break" : 0
		// 2 is defined independently by subclasses, do not reuse
		4: "Start inactive" : 0
		8: "Change mass to keep stable attachment to world" : 0
		16: "Do not connect entities until turned on" : 0
	]
	
	input Break(void) : "Force the constraint to break."
	input TurnOn(void) : "Enable the constraint.  Do this when the objects don't exist when the constraint spawns - or when you have deactivated the constraint.  Broken constraints can NOT be turned on.  They have been deleted."
	input TurnOff(void) : "Disable this constraint." 

	output OnBreak(void) : "Fired when the constraint breaks."
]

// Damage types specific to TF2
@BaseClass = DamageType :
	"A damage filter that filters by the type of damage inflicted. This can only be used as a damage filter, not as an activator filter. Does not function in Team Fortress 2."
[
	damagetype(choices) : "Damage Type" : 0 : "The damage type to use. Can be combinde by turning SmartEdit off and adding the desired damage type numbers together, such as 2 + 64 = 66." =
	[
		0 : "Generic (no pain sounds and no damage indicators)"
		1 : "Crush (red flash)"
		2 : "Bullet (bullet impact sounds)"
		4 : "Slash (double blood)"
		8 : "Burn (silent damage, does not ignite)"
		16 : "Train/Vehicle (displays train kill icon)"
		32 : "Fall (...fell to a clumsy painful death)"
		64 : "Blast (gibs on death)"
		128 : "Club (critical death scream) "
		256 : "Shock (smoke and sparks)"
		512 : "Sonic"
		1024 : "Energy Beam"
		2048 : "Prevent Physics Force (nullifies any physics force, such as fall damage)"
		4096 : "Never Gib (glitches the ragdoll, doesn't gib)"
		8192 : "Always Gib (glitches the ragdoll, doesn't gib)"
		16384: "Drown (blue flash and gurgles)"
		32768 : "Paralyse"
		65536 : "Sawblade (loud sawblade impact sound)"
		131072 : "Poison"
		262144 : "Radiation (critical damage, gibs on death)"
		524288 : "Drowning Recover"
		1048576 : "Critical Hit"
		2097152 : "Slow Burn"
		4194304 : "Remove, no ragdoll (leaves a glitchy ragdoll)"
		8388608 : "Physgun"
		16777216 : "Plasma"
		33554432 : "Airboat"
		67108864 : "Dissolve"
		134217728 : "Blast on Surface"
		268435456 : "Direct"
		536870912 : "Buckshot"
		1073741824 : "Last Generic Flag (???)"
//      CSS or CSGO only
//		2147483648 : "Headshot"
	]
]


// Some entities, but not all, use these in TF2
@BaseClass = TeamNum
[ 
	TeamNum(choices) : "Team" : "" : "Team of the entity. Does not change the entity's appearance!" =
	[
		"" : "< All >"
		0 : "0 - Any/Unassigned"
		1 : "1 - Spectator"	
		2 : "2 - RED"
		3 : "3 - BLU"
        4 : "4 - Mercenary"
	]
	
	input SetTeam(integer) : "Changes the entity's team. Does not change the entity's appearance!"
	input TeamNum(integer) : "Changes the entity's team, identical to SetTeam. Does not change the entity's appearance!"
]

// item_* entities use these
@BaseClass color(0 0 200) base(BaseAnimating, EnableDisable, TeamNum) studioprop() = Item
[
	model(studio) : "Model" :  : "Change the model to something other than the default model." 
	respawntime(integer) : "Respawn Time" : 10 : "Changes the time, in seconds, before the item respawns."
	respawndelay(integer) : "Initial Spawn Delay" : 0 : "Makes the item spawn after a initial delay."
	spawn_sound(sound): "Spawn Sound" : "Item.Materialize" : "Sound to play when Pickup Spawns."
	HiddenWhenRespawning(boolean) : "Hidden while Respawning?" : 1 : "Whether or not the pickup becomes hidden on pickup."	
	AutoMaterialize(boolean) : "Auto-Materialize?" : 1 : "The pickup should automatically materialize after being picked up."
	
	output OnPlayerTouch(void) : "Fires when the player touches this item."
	output OnCacheInteraction(void) : "This output fires when the player proves they have 'found' this item. Fires on: Player Touch (whether or not player actually acquires the item) or picked up by +USE."
]

@BaseClass = ResponseContext
[
    ResponseContext(string) : "Response Contexts" : "" : "Response system context(s) for this entity. Format should be: 'key:value,key2:value2,etc'. When this entity speaks, the list of keys & values will be passed to the response rules system."
	
	input AddContext(string) : "Adds a context to this entity's list of response contexts. The format should be 'key:value'."
	input RemoveContext(string) : "Remove a context from this entity's list of response contexts. The name should match the 'key' of a previously added context."
	input ClearContext(void) : "Removes all contexts in this entity's list of response contexts."
]

// TF2 Buildings
@BaseClass base(BaseAnimating, TeamNum) = BaseObject
[
	defaultupgrade(choices) : "Starting Upgrade Level" : 0 : "Starting upgrade level of the object. With higher levels, the objects gain more health/damage/recharge speed." =
	[
		0  : "Level 1"
		1  : "Level 2"
		2  : "Level 3"	
		3  : "Level 4"
		4  : "Level 5"	
		5  : "Level 6"	
		6  : "Level 7"	
		7  : "Level 8"	
		8  : "Level 9"	
		9  : "Level 10"	
		10 : "Level 11"	
		11 : "Level 12"	
		12 : "Level 13"
		13 : "Level 14"	
		14 : "Level 15"	
		15 : "Level 16"	
		16 : "Level 17"	
		17 : "Level 18"	
		18 : "Level 19"	
		19 : "Level 20"	
		20 : "Level 21"	
		21 : "Level 22"
		22 : "Level 23"	
		23 : "Level 24"	
		24 : "Level 25"	
		25 : "Level 26"	
		26 : "Level 27"	
		27 : "Level 28"	
		28 : "Level 29"	
		29 : "Level 30"	
		30 : "Level 31"
		31 : "Level 32"	
		32 : "Level 33"	
		33 : "Level 34"	
		34 : "Level 35"	
		35 : "Level 36"	
		36 : "Level 37"	
		37 : "Level 38"	
		38 : "Level 39"	
		39 : "Level 40"
		40 : "Level 41"	
		41 : "Level 42"	
		42 : "Level 43"	
		43 : "Level 44"	
		44 : "Level 45"	
		45 : "Level 46"	
		46 : "Level 47"	
		47 : "Level 48"	
		48 : "Level 49"
		49 : "Level 50"	
		50 : "Level 51"	
		51 : "Level 52"	
		52 : "Level 53"	
		53 : "Level 54"	
		54 : "Level 55"	
		55 : "Level 56"	
		56 : "Level 57"	
		57 : "Level 58"
		58 : "Level 59"	
		59 : "Level 60"	
		60 : "Level 61"	
		61 : "Level 62"	
		62 : "Level 63"	
		63 : "Level 64"	
		64 : "Level 65"	
		65 : "Level 66"	
		66 : "Level 67"
		67 : "Level 68"	
		68 : "Level 69"	
		69 : "Level 70"	
		70 : "Level 71"	
		71 : "Level 72"	
		72 : "Level 73"	
		73 : "Level 74"	
		74 : "Level 75"	
		75 : "Level 76"
		76 : "Level 77"	
		77 : "Level 78"	
		78 : "Level 79"	
		79 : "Level 80"	
		80 : "Level 81"	
		81 : "Level 82"	
		82 : "Level 83"	
		83 : "Level 84"	
		84 : "Level 85"
		85 : "Level 86"	
		86 : "Level 87"	
		87 : "Level 88"	
		88 : "Level 89"	
		89 : "Level 90"	
		90 : "Level 91"	
	]
	
	SolidToPlayer(boolean) : "Solid to Player?" : 1 : "Make the object solid or non-solid to players. The builder of the object will always be solid to the object."
	
	spawnflags(flags) =
	[
		2: "Invulnerable - Can still be sapped however" : 0
		4: "Upgradeable" : 0
		8: "Infinite Ammo" : 0
	]

	input SetBuilder(string) : "Sets the builder of this object, preferrably with !activator."
	input SetSolidToPlayer(bool) : "Sets the object to be solid or non-solid to players. 0 - non-solid, 1 - solid."
	input SetHealth(integer) : "Sets the current and maximum health. If the object is upgraded, the health will scale according to the new value. Crashes if set to 0."
	input AddHealth(integer) : "Increase the current health of the object. Does not surpass maximum health. Does not destroy the object if set at 0."
	input RemoveHealth(integer) : "Decrease current health of the object. Destroys the object if the health hits 0."
	input Show(void) : "Makes the object visible and re-enables it."
	input Hide(void) : "Makes the object invisible and disables it."
	input Enable(void) : "Enables the object and resets upgrade level to 1. Use Show instead."
	input Disable(void) : "Disables the object."

	output OnDestroyed(void) : "Sent when object dies."
	output OnDamaged(void) : "Sent when hurt."
	output OnRepaired(void) : "Sent when repaired."
	output OnDisabled(void) : "Sent when disabled."
	output OnReenabled (void) : "Sent when enabled."
	output OnObjectHealthChanged(integer) : "Sends current health as a parameter whenever a change occurs."
]

// all tf_projectiles_* use these
@BaseClass base(BaseAnimatingPhysics) = Projectile
[
	velocity(vector) : "Local Velocity" :  : "Velocity generated by the projectile, can cause strange behavior if changed with AddOutput."
	basevelocity(vector) : "Starting Base Velocity" :  : "Velocity to add onto the projectile upon spawning, in X Y Z."
	avelocity(vector) : "Starting Angular Velocity" :  : "Angular velocity to add onto projectile upon spawning,  in X Y Z."
]

// TF2 Player Conditions
@BaseClass = Condition
[
	condition(choices) : "Condition" : -1 : "The condition to use." =
	[
		-1 : "None"
		0 : "Slowed, as in when revving Minigun or zooming in with Sniper Rifles"
		1 : "Sniper Rifle zoom/scope"
		2 : "Disguise smoke"
		3 : "Disguise donning"
		4 : "Cloak effect"
		5 : "UberCharge"
		6 : "Teleporter dust"
		7 : "Taunting"
		8 : "UberCharge expiration"
		9 : "Cloaking flicker effect"
		10 : "Teleporting"
		11 : "Kritzkrieg, Revenge crits"
		12 : "Temporary damage buff"
		13 : "Dead Ringer Cloak buff"
		14 : "Bonk! Atomic Punch influence"
		15 : "Stunned"
		16 : "Buff Banner"
		17 : "Chargin' Targe charging"
		18 : "Eyelander glowing eye"
		19 : "Crit-a-Cola/Buffalo Steak Sandvich/Cleaner's Carbine effect"
		20 : "Amputator Medicating Melody effect"
		21 : "Continuous Healing"
		22 : "Ignite reaction (sound and speech, but no fire)"
		23 : "Overhealing"
		24 : "Jaratet"
		25 : "Bleeding"
		
		// Uncomment these if they ever get added
		//26 : "Battalion's Backup"
		//27 : "Mad Milk"
		//28 : "Quick-Fix visual effects + knock back/movement immunity"
		//29 : "Concheror"
		//30 : "Marked for death"
		//31 : "All attacks are mini-crits, with no glow"
		//32 : "Disciplinary Action"
		//33 : "Halloween pumpkin crit boost"
		//34 : "Canteen crit boost"
		//35 : "Demoman charge crit boost"
		//36 : "Soda Popper Hype"
		//37 : "First Blood Crit boost"
		//38 : "Winning Crit Boost"
		//39 : "Intelligence Capture crit boost"
		//40 : "Crit boost from crit-on-kill weapons"	
		//41 : "Cannot switch away from melee weapon"
		//42 : "Mann vs. Machine bomb carrier defensive buff"
		//43 : "Bot reprogramming"
		//44 : "Mmmph crit boost"
		//45 : "Mmmph activation defense buff"
		//46 : "Focus effect"
		//47 : "Causes the Enforcer to lose its 20% damage bonus"
		//48 : "Gloves of Running Urgently Marked for Death"
		//49 : "Disguised as Dispenser"
		//50 : "Sapping/sparkling particle"
		//51 : "Hidden UberCharge"
		//52 : "Canteen UberCharge or UberCharge powerup"
		//53 : "Bombinomicon Head"
		//54 : "Forced Thriller taunting"
		//55 : "Amputator Heal"
		//56 : "Miscellaneous Crit boost"
		//57 : "Miscellaneous UberCharge"
		//58 : "Vaccinator Uber bullet resistance"
		//59 : "Vaccinator Uber blast resistance"
		//60 : "Vaccinator Uber fire resistance"
		//61 : "Vaccinator passive bullet resistance"
		//62 : "Vaccinator passive blast resistance"
		//63 : "Vaccinator passive fire resistance"
		//64 : "Cloak/Invisibility"
		//65 : "Medigun Debuff"
		//66 : "Cloak/Invisibility fading"
		//67 : "Bullet damage immunity"
		//68 : "Blast damage immunity"
		//69 : "Fire damage immunity"
		//70 : "Survive all damage until at 1 health"
		//71 : "MvM Bot Gate-Capture Stun"
		//72 : "Minify Boost"
		//73 : "Uber Heal"
		//74 : "Giant"
		//75 : "Minify"
		//76 : "Becomes a Ghost on Death"
		//77 : "Becomes a Ghost"
		//78 : "Mini-crit boost"
		//79 : "75% chance to dodge damage"
		//80 : "Parachute if airborne"
		//81 : "Fire rate bonus"
		//82 : "Bumper Car"
		//83 : "Bumper Car Boosting"
		//84 : "Large head and lower gravity"
		//85 : "Melee weapons only"
		//86 : "Swim in Jarate"
		//87 : "Player is locked in place"
		//88 : "Cage surrounds player (crashes on non-bumper car maps)"
		//90 : "Strength powerup"
		//91 : "Haste powerup"
		//92 : "Regeneration powerup"
		//93 : "Resistance powerup"
		//94 : "Vampire powerup"
		//95 : "Reflect powerup"
		//96 : "Precision powerup"
		//97 : "Agility powerup"
		//98 : "Grappling Hook firing"
		//99 : "Grappling Hook pulling"
		//100 : "Grappling Hook latches to a wall"
		//101 : "Grappling Hook bleeding"
		//102 : "Dead Ringer afterburn immunity"
		//103 : "Knockout powerup"
		//104 : "Prevents pickup of Uber or Crit powerup"
		//105 : "Mannpower Crit powerup"
		//106 : "PASS Ball Intercepted by player"
		//107 : "Swimming with no overlay/animations"
		//108 : "Purgatory (escaped Underworld)"
		//109 : "The King powerup"
		//110 : "The Plague powerup"
		//111 : "The Supernova powerup"
		//112 : "Plagued by the Plague powerup"
		//113 : "King powerup Area Buff"
		//114 : "Glow outlines on teammates"
		//115 : "Under effect of compression blast"
		//116 : "In competitive winning"
		//117 : "In competitive losing"
		//118 : "Healing debuff from flamethrower"
		//119 : "PASS Ball Marked for Death"
		//120 : "Grappled to Player"
		//121 : "Grapplyed by Player"
		//122 : "Parachute deployed"
		//123 : "Gas coating from Gas Passer"
		//124 : "Afterburn applied to Pyros by Dragon's Fury."
		//125 : "Thermal Thruster flying"
		//126 : "Decreases the player's friction while moving"
		//127 : "Under the influence of air current"
		//128 : "Halloween Hell Heal"
		
		129 : "Spawn Protection"
		130 : "Berserk"
		131 : "Shield"
		132 : "Crit Powerup"
		133 : "Invis Powerup"
		134 : "Haste"
	]
]

// CondID variant
@BaseClass = CondID
[
	condID(choices) : "Condition" : -1 : "The condition to use." =
	[
		-1 : "None"
		0 : "Slowed, as in when revving Minigun or zooming in with Sniper Rifles"
		1 : "Sniper Rifle zoom/scope"
		2 : "Disguise smoke"
		3 : "Disguise donning"
		4 : "Cloak effect"
		5 : "UberCharge"
		6 : "Teleporter dust"
		7 : "Taunting"
		8 : "UberCharge expiration"
		9 : "Cloaking flicker effect"
		10 : "Teleporting"
		11 : "Kritzkrieg, Revenge crits"
		12 : "Temporary damage buff"
		13 : "Dead Ringer Cloak buff"
		14 : "Bonk! Atomic Punch influence"
		15 : "Stunned"
		16 : "Buff Banner"
		17 : "Chargin' Targe charging"
		18 : "Eyelander glowing eye"
		19 : "Crit-a-Cola/Buffalo Steak Sandvich/Cleaner's Carbine effect"
		20 : "Amputator Medicating Melody effect"
		21 : "Continuous Healing"
		22 : "Ignite reaction (sound and speech, but no fire)"
		23 : "Overhealing"
		24 : "Jaratet"
		25 : "Bleeding"
		
		// Uncomment these if they ever get added
		//26 : "Battalion's Backup"
		//27 : "Mad Milk"
		//28 : "Quick-Fix visual effects + knock back/movement immunity"
		//29 : "Concheror"
		//30 : "Marked for death"
		//31 : "All attacks are mini-crits, with no glow"
		//32 : "Disciplinary Action"
		//33 : "Halloween pumpkin crit boost"
		//34 : "Canteen crit boost"
		//35 : "Demoman charge crit boost"
		//36 : "Soda Popper Hype"
		//37 : "First Blood Crit boost"
		//38 : "Winning Crit Boost"
		//39 : "Intelligence Capture crit boost"
		//40 : "Crit boost from crit-on-kill weapons"	
		//41 : "Cannot switch away from melee weapon"
		//42 : "Mann vs. Machine bomb carrier defensive buff"
		//43 : "Bot reprogramming"
		//44 : "Mmmph crit boost"
		//45 : "Mmmph activation defense buff"
		//46 : "Focus effect"
		//47 : "Causes the Enforcer to lose its 20% damage bonus"
		//48 : "Gloves of Running Urgently Marked for Death"
		//49 : "Disguised as Dispenser"
		//50 : "Sapping/sparkling particle"
		//51 : "Hidden UberCharge"
		//52 : "Canteen UberCharge or UberCharge powerup"
		//53 : "Bombinomicon Head"
		//54 : "Forced Thriller taunting"
		//55 : "Amputator Heal"
		//56 : "Miscellaneous Crit boost"
		//57 : "Miscellaneous UberCharge"
		//58 : "Vaccinator Uber bullet resistance"
		//59 : "Vaccinator Uber blast resistance"
		//60 : "Vaccinator Uber fire resistance"
		//61 : "Vaccinator passive bullet resistance"
		//62 : "Vaccinator passive blast resistance"
		//63 : "Vaccinator passive fire resistance"
		//64 : "Cloak/Invisibility"
		//65 : "Medigun Debuff"
		//66 : "Cloak/Invisibility fading"
		//67 : "Bullet damage immunity"
		//68 : "Blast damage immunity"
		//69 : "Fire damage immunity"
		//70 : "Survive all damage until at 1 health"
		//71 : "MvM Bot Gate-Capture Stun"
		//72 : "Minify Boost"
		//73 : "Uber Heal"
		//74 : "Giant"
		//75 : "Minify"
		//76 : "Becomes a Ghost on Death"
		//77 : "Becomes a Ghost"
		//78 : "Mini-crit boost"
		//79 : "75% chance to dodge damage"
		//80 : "Parachute if airborne"
		//81 : "Fire rate bonus"
		//82 : "Bumper Car"
		//83 : "Bumper Car Boosting"
		//84 : "Large head and lower gravity"
		//85 : "Melee weapons only"
		//86 : "Swim in Jarate"
		//87 : "Player is locked in place"
		//88 : "Cage surrounds player (crashes on non-bumper car maps)"
		//90 : "Strength powerup"
		//91 : "Haste powerup"
		//92 : "Regeneration powerup"
		//93 : "Resistance powerup"
		//94 : "Vampire powerup"
		//95 : "Reflect powerup"
		//96 : "Precision powerup"
		//97 : "Agility powerup"
		//98 : "Grappling Hook firing"
		//99 : "Grappling Hook pulling"
		//100 : "Grappling Hook latches to a wall"
		//101 : "Grappling Hook bleeding"
		//102 : "Dead Ringer afterburn immunity"
		//103 : "Knockout powerup"
		//104 : "Prevents pickup of Uber or Crit powerup"
		//105 : "Mannpower Crit powerup"
		//106 : "PASS Ball Intercepted by player"
		//107 : "Swimming with no overlay/animations"
		//108 : "Purgatory (escaped Underworld)"
		//109 : "The King powerup"
		//110 : "The Plague powerup"
		//111 : "The Supernova powerup"
		//112 : "Plagued by the Plague powerup"
		//113 : "King powerup Area Buff"
		//114 : "Glow outlines on teammates"
		//115 : "Under effect of compression blast"
		//116 : "In competitive winning"
		//117 : "In competitive losing"
		//118 : "Healing debuff from flamethrower"
		//119 : "PASS Ball Marked for Death"
		//120 : "Grappled to Player"
		//121 : "Grapplyed by Player"
		//122 : "Parachute deployed"
		//123 : "Gas coating from Gas Passer"
		//124 : "Afterburn applied to Pyros by Dragon's Fury."
		//125 : "Thermal Thruster flying"
		//126 : "Decreases the player's friction while moving"
		//127 : "Under the influence of air current"
		//128 : "Halloween Hell Heal"
		
		129 : "Spawn Protection"
		130 : "Berserk"
		131 : "Shield"
		132 : "Crit Powerup"
		133 : "Invis Powerup"
		134 : "Haste"
	]
]

@BaseClass = weaponname
[
	weaponname(choices) : "Weapon" : "tf_weapon_shotgun_mercenary" : "The weapon to use." =
	[
		"0"									  : "=== Deathmatch ==="
		"tf_weapon_assaultrifle"			  : "Assault Rifle"
		"tf_weapon_dynamite_bundle"			  : "Dynamite Bundle"
		"tf_weapon_flamethrower"              : "Flamethrower"
		"tf_weapon_gatlinggun"                : "Gatling Gun"
		"tf_weapon_gib"			  			  : "The G.I.B."
		"tf_weapon_physcannon"                : "Gravity Gun"
		"tf_weapon_grenadelauncher_mercenary" : "Grenade Launcher"
		"tf_weapon_knife"                     : "Knife"
		"tf_weapon_lightning_gun"             : "Lightning Gun"
		"tf_weapon_nailgun"                   : "Nailgun"
		"tf_weapon_railgun"                   : "Railgun"
		"tf_weapon_revolver_mercenary"        : "Revolver"	
		"tf_weapon_rocketlauncher_dm"         : "Rocket Launcher"
		"tf_weapon_scattergun"                : "Scattergun"
		"tf_weapon_shotgun_mercenary"         : "Shotgun"
		"tf_weapon_smg_mercenary"             : "Combat SMG"
		"tf_weapon_sniperrifle"               : "Sniper Rifle"
		"tf_weapon_pipebomblauncher"          : "Stickybomb Launcher"
	    "tf_weapon_sword"                     : "Sword"
	    "tf_weapon_syringegun_medic"          : "Syringegun"
		"tf_weapon_supershotgun"              : "Super Shotgun"	
	    "tf_weapon_tommygun"                  : "Tommygun"
		"tf_weapon_super_rocketlauncher"      : "Super Rocketlauncher"
	    "tf_weapon_tripmine"                  : "Tripmine"
		
		"0"									  : "=== Do Not Use In Deathmatch ==="
		"tf_weapon_grenadelauncher"           : "Grenade Launcher (Demoman)"
		"tf_weapon_minigun"                   : "Minigun"
		"tf_weapon_pistol_mercenary"          : "Pistol (Mercenary)"
		"tf_weapon_pistol_akimbo"             : "Akimbo Pistols"
		"tf_weapon_pistol"                    : "Pistol (Engineer)"
		"tf_weapon_pistol_scout"              : "Pistol (Scout)"
		"tf_weapon_revolver"                  : "Revolver (Spy)"
		"tf_weapon_rocketlauncher"            : "Rocket Launcher (Soldier)"
		"tf_weapon_shotgun_hwg"               : "Shotgun (Heavy)"
		"tf_weapon_shotgun_pyro"              : "Shotgun (Pyro)"
		"tf_weapon_shotgun_primary"           : "Shotgun (Engineer)"
		"tf_weapon_shotgun_soldier"           : "Shotgun (Soldier)"
		"tf_weapon_smg"                       : "SMG (Sniper)"
		"tf_weapon_medigun"                   : "Medigun"
		"tf_weapon_bat"                       : "Bat"
		"tf_weapon_bonesaw"                   : "Bonesaw"
		"tf_weapon_bottle"                    : "Bottle"
		"tf_weapon_club"                      : "Kukri"
		"tf_weapon_crowbar"                   : "Crowbar"
		"tf_weapon_fireaxe"                   : "Fireaxe"
		"tf_weapon_fists"                     : "Fists"
		"tf_weapon_shovel"                    : "Shovel"
		"tf_weapon_umbrella"                  : "Umbrella"
		"tf_weapon_wrench"                    : "Wrench"
	]
]	

// ---------------------------------------
//             Entities A - Z
// ---------------------------------------

@PointClass base(BaseEntityPoint) sphere(radius) iconsprite("editor-ficool2/ambient_generic") = ambient_generic :
    "It plays a sound, either once or on loop, and either from a location in the world or globally."
[
	message(sound) : "Sound Name" :  : "The soundscript name of, or direct path to, the sound to play. For scripted sentences, type '!' followed by the sentence name. If the sound needs to be recognised as 'music' by the engine, precede the path with a '#'."
	health(integer) : "Volume" : 10 : "Sound volume, expressed as a range from 0 to 10, where 10 is the loudest."
	radius(string) : "Max Audible Distance" : "1250" : "Maximum distance at which this sound is audible."
	SourceEntityName(target_destination) : "SourceEntityName" : : "If an entity is specified, sound will come from this named entity instead of the location of ambient_generic. If the target is capable of lipsynching, and phoneme data is found within the sound, the target will lip-sync to it. If the target is killed, it will result in the sound playing from the 0 0 0 co-ordinate of the map. Parenting can be used as a workaround."	
	preset(choices) : "Dynamic Presets" : 0 : "Various DSP effects that can be applied." =
	[
		0: "None"
		1: "Huge Machine"
		2: "Big Machine"
		3: "Machine"
		4: "Slow Fade in"  
		5: "Fade in"
		6: "Quick Fade in"
		7: "Slow Pulse"
		8: "Pulse"
		9: "Quick pulse"
		10: "Slow Oscillator"
		11: "Oscillator"
		12: "Quick Oscillator"
		13: "Grunge pitch"
		14: "Very low pitch"
		15: "Low pitch"
		16: "High pitch"
		17: "Very high pitch"
		18: "Screaming pitch"
		19: "Oscillate spinup/down"
		20: "Pulse spinup/down"
		21: "Random pitch"
		22: "Random pitch fast"
		23: "Incremental Spinup"
		24: "Alien"
		25: "Bizzare"
		26: "Planet X"
		27: "Haunted"
	]
	volstart(integer) : "Start Volume" : 0 : "The starting volume of this sound. When the entity is triggered, the volume will either go down to 0 or up to the Full Volume, depending on which input you send the ambient_generic."
	fadeinsecs(integer) : "Fade In time (0-100)" : 0 : "Time taken to fade the sound from 0 volume to 100% volume.  Measured as a percentage of the sound's length."
	fadeoutsecs(integer) : "Fade Out time (0-100)" : 0 : "Time taken to fade the sound from 100% volume to 0 volume.  Measured as a percentage of the sound's length."
	pitch(integer) : "Full Pitch" : 100 : "Sound pitch, expressed as a range from 1 to 255, where 100 is the sound's default pitch."
	pitchstart(integer) : "Start Pitch" : 100 : "The starting pitch of the sound."
	spinup(integer) : "Spin Up time (0-100)" : 0 : "Same as fade in time, but for pitch, not volume."
	spindown(integer) : "Spin Down time (0-100)" : 0 : "Same as fade out time, but for pitch, not volume."
	lfotype(choices) : "LFO type" : 0 : "The type of vibrato to apply to the sound.  (LFO = low-frequency oscillator = vibrato)" =
	[
		0 : "Off"
		1 : "Square: full up or down, never middle"
		2 : "Triangle:  fade between up and down"
		3 : "Random"
	]
	lforate(integer) : "LFO rate (0-1000)" : 0 : "Rate of pitch changes if an LFO type is specified."
	lfomodpitch(integer) : "LFO mod pitch (0-100)" : 0 : "Amount by which to change the pitch if an LFO type is selected."
	lfomodvol(integer) : "LFO mod volume (0-100)" : 0 : "Amount by which to change the volume if an LFO type is selected."
	cspinup(integer) : "Incremental Spinup Count (1-100)" : 0 : "When nonzero, scales the amount by which the pitch of the sound is increased with each PlaySound input until the pitch reaches the maximum supported."
	
	spawnflags(flags) =
	[
		1 : "Play Everywhere (not compatible with soundscripts)" : 0
		16 : "Start Silent (MUST use with looping sounds)" : 1
		32 : "Is NOT Looped" : 1
	]

	input AddVolume(float) : "Add more volume to the sound."
	input Pitch(integer) : "Starts the sound and sets the sound pitch, expressed as a range from 1 to 255, where 100 is the sound's default pitch."
	input PlaySound(void) : "Starts the sound."
	input StopSound(void) : "Stops the sound if it is playing. Does not stop a non-looping sound, in which case the Volume input can be used with a value of 0."
	input ToggleSound(void) : "Toggles the sound between playing and stopping."
	input Volume(integer) : "Starts the sound and sets the sound volume, expressed as a range from 0 to 10, where 10 is the loudest. A value of 0 will cause the sound to stop playing."
	input FadeIn(integer) : "Fades the sound up to full volume over a specified number of seconds, with a range from 0 to 100 seconds."
	input FadeOut(integer) : "Brings up the Volume to 10 and fades the sound to silence over a specified number of seconds, with a range from 0 to 100 seconds."
]

@PointClass base(BaseNPC) studioprop() = base_boss : 
    "Generic NPC that does absolutely nothing. "
[
	health(integer) : "Health" : 1000 : "Starting health of this entity. Cannot exceed Max Health."
	max_health(integer) : "Max Health" : 1000 : "Maximum health of this entity."

	start_disabled(choices) : "Start Disabled?" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]
]

@PointClass base(BaseEntity, EnableDisable) sphere(minfalloff) sphere(maxfalloff) iconsprite("editor-ficool2/color_correction") = color_correction : 
	"An entity to control the color correction in the map.  It loads a color correction lookup table (.raw) and controls its strength. Correction is applied in a sphere surrounding the entity, with a configurable amount of falloff."
[
	minfalloff(float) : "Lookup Falloff Start Distance" : "0.0"   : "Within this range to the entity, the effect will be at full strength. If this is larger than the End Distance, the effect will apply to the entire map."
	maxfalloff(float) : "Lookup Falloff End Distance"   : "200.0" : "Maximum distance from the entity that the effect is applied. At this distance, the effect is barely apparent but will strengthen as the viewer approaches the Start Distance."
	maxweight(float)  : "Maximum Weight"				: "1.0"   : "This is the maximum weight for this lookup."
	filename(string)  : "Lookup Table Filename"			: 	  : "This is the lookup table filename."
	fadeInDuration(float)   : "Lookup Fade In Duration"		: "0.0"	  : "When the entity becomes Enabled, how long the effect takes to fade in."
	fadeOutDuration(float)   : "Lookup Fade out Duration"		: "0.0"	  : "When the entity becomes Disabled, how long the effect takes to fade out."
	
	input SetFadeInDuration(float) : "Sets the Lookup Fade In Duration."
	input SetFadeOutDuration(float) : "Sets the Lookup Fade out Duration."
]

@SolidClass base(Trigger) = color_correction_volume : 
	"A color correction lookup table is faded in or out when a player enters or leaves its volume. Fade time is configurable. "
[
	fadeDuration(float) : "Lookup Fade Duration"  : "10.0" : "How fast the effect fades in or out when the viewer enters or exits."
	maxweight(float)    : "Maximum Weight"		  : "1.0"  : "This is the maximum weight for this lookup."
	filename(string)    : "Lookup Table Filename" :      : "This is the lookup table filename."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/commentary_auto") = commentary_auto : 
	"Fires outputs based on how commentary mode has been activated."
[
	input MultiplayerSpawned(void) : "Fires the OnCommentaryMultiplayerSpawn output."
	
	output OnCommentaryNewGame(void) : "Fires when a new game is started with commentary enabled."
	output OnCommentaryMidGame(void) : "Fires when commentary is enabled midgame."
	output OnCommentaryMultiplayerSpawn(void) : "Fires when the MultiplayerSpawned input is used."
]

@SolidClass base(BaseEntityBrush, EnableDisable) = dispenser_touch_trigger :
    "Trigger for a dispenser healing bounds."
[
	StartDisabled(boolean) : "Start Disabled?" : 0 : "NOTE: This entity only controls healing zone. Disabling it will still allow ammo resupply."
]

@PointClass base(Item, CondID) studioprop() = dm_powerup_spawner :	
    "Adds a condition to the player upon being touched." 
[
	model(studio) : "Model" :  : "Show a model." 
	duration(float) : "Duration" : 5 : "Changes the time, in seconds, before the condition fades."
]

@PointClass base(BaseAnimating, EnableDisable, TeamNum, weaponname) size(-1 -1 -48, 1 1 -8) studioprop() = dm_weapon_spawner :	
    "Spawns a weapon." 
[
	Index(integer) : "Index" : 0 : "Index used to pull from MapData"
	model(studio) : "Model" : "" : "Overwrite the default model with a custom one."
	
	skin(integer) : "Skin" : 2 : "Some models have multiple skins. This value selects from the index, starting with 0."
	
	respawntime(integer) : "Respawn Time" : 10 : "Changes the time, in seconds, before the item respawns."
	respawndelay(integer) : "Initial Spawn Delay" : 0 : "Makes the item spawn after a initial delay."
	spawn_sound(sound): "Spawn Sound" : "Item.Materialize" : "Sound to play when Pickup Spawns."
	pickup_sound(sound): "Pickup Sound" : "AmmoPack.Touch" : "Sound to play when picking up ammo."	
	
	HiddenWhenRespawning(boolean) : "Hidden while Respawning?" : 1 : "Whether or not the pickup becomes hidden on pickup."
	AutoMaterialize(boolean) : "Auto-Materialize?" : 1 : "The pickup should automatically materialize after being picked up."
	disable_spin(boolean) : "Disable Spinning?" : 0 : "If set to Yes, the spawned weapon will not spin."
	disable_glow(boolean) : "Disable Glowing?" : 0 : "If set to Yes, the spawned weapon will not glow."
	
	output OnPlayerTouch(void) : "Fires when the player touches this item."
	output OnCacheInteraction(void) : "This output fires when the player proves they have 'found' this item. Fires on: Player Touch (whether or not player actually acquires the item) or picked up by +USE."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/entity_spawn_manager") = entity_spawn_manager : 
    "An entity that spawns an entity class at entity_spawn_points."
[
	entity_name(string) : "Entity Name" :  : "Name of the entity class we are supposed to spawn."
	entity_count(integer) : "Count" : 0 : "Max number of entities to have spawned at one time, if points are available."
	respawn_time(integer) : "Respawn Time" : 0 : "Time to wait before we spawn a new entity when one is destroyed."
	drop_to_ground(choices) : "Drop to Ground?" : 0 : "Should entities spawn on the ground beneath the entity_spawn_point or float at its location?" =
	[
		0 : "No"
		1 : "Yes"
	]
	random_rotation(choices) : "Random Rotation?" : 0 : "Should entities be rotated to random angles upon spawn?" =
	[
		0 : "No"
		1 : "Yes"
	]
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/entity_spawn_point") = entity_spawn_point : 
    "A spawn location associated with an entity_spawn_manager."
[
	spawn_manager_name(string) : "Spawn Manager Name" :  : "Name of the spawn manager entity we are associated with."
]

@PointClass base(BaseEntity, Render) iconsprite("editor-ficool2/env_beam") line(255 255 255, targetname, LightningStart, targetname, LightningEnd) sphere(radius) = env_beam : 
	"An entity that creates a visible beam between two points. The points can be attached to entities to make the beam move around. Warning: don't parent the env_beam itself, parent its 2 points instead."
[
	Radius(integer) : "Radius" : 0 : "If the Start Entity and/or Ending Entity values are omitted, this radius determines the area within which the endpoints will randomly strike. A new random position will be appointed for every strike."
	life(string) : "Life (seconds 0 = infinite)" : "1" : "Amount of time before the beam dies. Setting to zero will make the beam stay forever."
	StrikeTime(string) : "Strike again time (secs)" : "1" : "Refire time between random strikes of the beam. Only used if the 'Random Strike' spawnflag is set."
	
	damage(string) : "Damage / second" : "0" : "How much damage this beam does per second to things it hits when it is continually on, or instantaneously if it strikes. For continuous damage, the value should be greater than 10 or it may not work."
	dissolvetype(choices) : "Dissolve Type" : "-1" : "If this beam damages and kills something, effects to show around the object. " =
	[
		-1 : "None"
		0 : "Energy"
		1 : "Heavy electrical"
		2 : "Light electrical"
	]
	
	LightningStart(target_destination) : "Start Entity" :  : "Entity that the beam starts at. If omitted the entity will instead use a random position on any surface within its Radius value. A new random position will be appointed for every strike."
	LightningEnd(target_destination) : "Ending Entity" :  : "Entity that the beam ends at. If omitted the entity will instead use a random position on any surface within its Radius value. A new random position will be appointed for every strike."

	BoltWidth(float) : "Width (1 - 25.5)" : 2 : "Pixel width of the beam."
	NoiseAmplitude(float) : "Amount of noise (0-64)" : 0 : "The amount of noise in the beam. 0 is a perfectly straight beam."	
	
	texture(sprite) : "Sprite Name" : "sprites/laserbeam.spr" : "The material used to draw the beam."
	TextureScroll(integer) : "Texture Scroll Rate (0-100)" : 35 : "Rate at which the beam texture should scroll along the beam."	framerate(integer) : "Frames per 10 seconds" : 0 : "Framerate at which the beam texture should animate, if it has multiple frames."
	framestart(integer) : "Starting Frame" : 0 : "The frame to start the beam texture on."
	decalname(string) : "Decal Name" : "Bigshot" : "Decal to be applied at the end of the beam."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Value to multiply beam color by when running in HDR mode."
	
	filtername(filterclass) : "Filter Name" : : "Filter to use to see if activator triggers me."	
	TouchType(choices) : "Touch Type (tripwire)" : 0 : "If you want the beam to fire an output when touched by entities, choose the entity type here." =
	[	
		0 : "Not a tripwire"
		1 : "Player Only"
		2 : "NPC Only"
		3 : "Player or NPC"
		4 : "Player or NPC or Physprop"
	]	
	
	spawnflags(flags) = 
	[
		1 : "Start On" : 0
		2 : "Toggle - Obsolete, replaced by the Toggle input." : 0
		4 : "Random Strike - When the beam has died, it will strike again randomly within the time set by Strike again time (secs)." : 0
		8 : "Ring - Uses the starting and ending points as a diameter, drawing a beam ring between them instead of a straight line." : 0
		16: "StartSparks - Every time the beam strikes or is turned on, the beam emits a small shower of sparks at its Start Entity." : 0
		32: "EndSparks - Every time the beam strikes or is turned on, the beam emits a small shower of sparks at its Ending Entity." : 0
		64: "Decal End - Places a decal scorch mark where a damaging beam hits the first solid object (world brush or entity)." : 0
		128: "Shade Start - Fades out toward its Start Entity. Overrides Shade End. Does not work on striking beams or beam rings." : 0
		256: "Shade End - Fades out toward its Ending Entity. Is overridden by Shade Start. Does not work on striking beams or beam rings." : 0
		512: "Taper Out - Taper out into a point towards its Ending Entity. Does not work on striking beams or beam rings." : 0
	]

	input TurnOn(void) : "Turns the beam on."
	input TurnOff(void) : "Turns the beam off."
	input Toggle(void) : "Toggles the beam between on and off."
	input StrikeOnce(void) : "Causes the beam to strike once. It will stay on for its set Life and then turn off (it will never turn off if Life is set to zero)."
	input Alpha(integer) : "Sets the beam's alpha (0 - 255)."
	input Color(color255) : "Sets the beam's color (R G B)."
	input ColorRedValue(float) : "Sets the red color channel's value (0 - 255)."
	input ColorGreenValue(float) : "Sets the green color channel's value (0 - 255)."
	input ColorBlueValue(float) : "Sets the blue color channel's value (0 - 255)."
	input Noise(float) : "Set how far away from the middle the beam is allowed to deviate. (0 - 64)"
	input ScrollSpeed(float) : "Set the scroll speed in units per second (0 - 100)."
	input Width(float) : "Set the width of the beam, in pixels. (1 - 25.5) "

	output OnTouchedByEntity(void) : "Fired when an entity touches the beam. Only fired if the entity passes the 'Touch Type' choice."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_beverage") = env_beverage : 
	"An entity that dispenses soda cans upon activation. Uses models/can.mdl by default, you will need to provide your own with the map/mod as the model is not present."
[
	health(integer) : "Capacity" : 10 : "Number of cans in the dispenser."
	beveragetype(choices) : "Skin (beverage type)" : 6 : "Sets the texture of the beverage using skins embedded into the model."  =
	[
		0 : "0"
		1 : "1"
		2 : "2"
		3 : "3"
		4 : "4"
		5 : "5"
		6 : "Random"
	]

	input Activate(void) : "Enable this dispenser."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_blood") = env_blood : 
	"An entity used to spawn blood effects." 
[
	spraydir(angle) : "Spray Direction (Pitch Yaw Roll)" : "0 0 0" : "The general direction that the blood should spray and the direction to trace to apply the decal."
	color(choices) : "Blood Color" : 0 =
	[
		0 : "Red (Human)"
		1 : "Yellow (Alien)"
	]
	amount(string) : "Amount of blood (damage to simulate)" : "100" : "Intensity of the blood spray."
	
	spawnflags(flags) =
	[
		1: "Random Direction" : 0
		2: "Blood Stream" : 0
		4: "Spray onto the activating player" : 0
		8: "Spray decals" : 0
		16: "Cloud - emits larger cloud of blood" : 0
		32: "Drops - splashes large blood drops" : 1
		64: "Gore - similar to Cloud but smaller" : 0
	]

	input EmitBlood(void) : "Triggers the blood effect."
]
// Inherting BaseEntityBrush WITHOUT origin, as for some reason that breaks the entire entity
@SolidClass base(BaseEntityBrush) = env_bubbles : 
	"An entity used to create a volume in which to spawn bubbles." 
[
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."

	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	
	linedivider2(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	density(integer) : "Bubble density" : 2 : "Bubble count in volume."
	frequency(integer) : "Bubble frequency" : 2 : "Bubble emission frequency, in bubbles per second."
	current(integer) : "Speed of Current" : 0 : "The speed of the water current in the volume, used to move the bubbles."
	
	spawnflags(flags) = 
	[
		1 : "Start Off"  : 0
	]
	
	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"

	input Activate(void) : "Activates the bubbles."
	input Deactivate(void) :  "Deactivates the bubbles."
	input Toggle(void) :  "Toggles the bubbles on and off."
	input SetDensity(integer) : "Sets the bubble density."
	input SetFrequency(integer) : "Sets bubble emission rate in bubbles per second."
	input SetCurrent(integer) : "Sets current speed in units per second."
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_credits") = env_credits : 
	"An entity to control the rolling credits. Crashes the game if used!"
[ 
	input RollCredits(void) : "Start the intro credits rolling."
	input RollOutroCredits(void) : "Start the outro credits rolling."
	input ShowLogo(void) : "Show the Half Life 2 logo."

	output OnCreditsDone(void)  : "Fired when the credits having finished rolling."
]

@PointClass color(0 0 255) size(-1 -1 -64, 1 1 -8) sidelist(sides) iconsprite("editor/env_cubemap") = env_cubemap : 
	"An entity that creates a sample point for the Cubic Environment Map."
[
	cubemapsize(choices) : "Cubemap Size" : 0 : "The cubemap size to produce. Attempting to use a cubemap size larger than your monitor will cause cubemap creation to fail completely!" =
	[
		0 : "Default"
		1 : "1x1"
		2 : "2x2"
		3 : "4x4"
		4 : "8x8"
		5 : "16x16"
		6 : "32x32"
		7 : "64x64 (18 KB)"
		8 : "128x128 (75 KB)"
		9 : "256x256 (300 KB)"
		10 : "512x512 (1200 KB - 1 MB)"
		11 : "1024x1024 (4800 KB - 5 MB!)"
		12 : "2048x2048 (19100 KB - 19 MB!!)"
		13 : "4096x4096 (76500 KB - 75 MB!!!)"
	]
	sides(sidelist) : "Brush faces": : "(Optional) Brushes faces to directly attach to the env_cubemap. Press Pick then click on faces in the 3D View to select them. Use CTRL while clicking to add or remove from the selection."
]


@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_detail_controller") sphere(fademindist) sphere(fademaxdist) = env_detail_controller : 
    "An entity that overrides the fade distances for all details sprites in the map."
[
	fademindist(float) : "Start Fade Dist/Pixels" : 400 : "The distance at which the detail props will start fading away."
	fademaxdist(float) : "End Fade Dist/Pixels" : 1200 : "The distance at which the detail props will stop fading and stop drawing entirely."
]

// iconsprite removed due to scale keyvalue affecting it and making it massive
@PointClass base(BaseEntity) color(200 200 0) = env_dustpuff : 
	"An entity that emits dust puffs."
[
	scale(float) : "Scale" : "0.25" : "Size of the dust puff."
	speed(float) : "Speed" : 16 : "Speed at which the dust particles should move."
	color(color255) : "Dust color" : "128 128 128" : "Color of the dust particles."

	input SpawnDust(void) : "Spawn a dust puff."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_dusttrail") sphere(spawnradius) = env_dusttrail : 
	"An entity that emits dust 'trails' upon spawning. Lacks enabling/disabling functionality. To make this an actual trail of dust, it must be parented to something."
[
	opacity(float) : "Opacity" : 255 : "The opacity of the dust trails."
	spawnrate(float) : "Spawn Rate" : 10 : "Speed at which the dust trails spawn."
	lifetime(float) : "Lifetime" : 5 : "The time before the entity restarts, in seconds."
	minspeed(float) : "Min Speed" : 2 : "Minimum speed of the dust trails."
	maxspeed(float) : "Max Speed" : 4 : "Maximum speed of the dust trails."
	mindirectedspeed(float) : "Min Directed Speed" : 0 : "Minimum directed speed of the dust trails."
	maxdirectedspeed(float) : "Max Directed Speed" : 0 : "Maximum directed speed of the dust trails."
	startsize(float) : "Start Size" : 35 : "Minimum size of the dust trails."
	endsize(float) : "End Size" : 55 : "Maximum size of the dust trails."
	spawnradius(float) : "Spawn Radius" : 2 : "Spawn radius of dust trails."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_effectscript") = env_effectscript : 
	"An entity that allows you to script special visual effects via a script file."
[
	model(studio) : "Script Model" : "models/Effects/teleporttrail.mdl" : "Model to use for animation sequences."
	scriptfile(string) : "Script File" : "scripts/effects/testeffect.txt" : "Name of the script to use for this model." 

	input SetSequence(string) : "Sets the script model's sequence."
]

@SolidClass base(BaseEntityBrush) = env_embers : 
	"An entity used to create a volume in which to spawn fire embers. For some reason its state can only be changed with the Use input." 
[
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."

	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	
	linedivider2(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	density(integer) : "Density (particles per second)" : 50 : "Number of particles spawned each second."
	lifetime(integer) : "Particle Lifetime (seconds)" : 4 : "Number of seconds each particle lasts for. A certain amount of randomness is added proportional to the time specified here."
	speed(integer) : "Particle Speed (units per second)" : 32 : "Number of units moved by particles each second."
	rendercolor(color255) : "Ember Color (R G B)" : "255 255 255" : "Color of the sprites."

	spawnflags(Flags) = 
	[
		1 : "Start On"  : 0
		2 : "Toggle" : 0
	]
	
	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"

	input Color(color255) : "Changes the color that new sprites will spawn with."
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]



@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_entity_dissolver") = env_entity_dissolver:
    "An entity dissolver that removes a point entity from the map after a few built-in effects. Does not work on brush entities."
[
	target(target_destination) : "Target to Dissolve" :  : "The entity to dissolve."
	magnitude(integer) : "Magnitude" : 250 : "How strongly to push away from the center."
	dissolvetype(choices) : "Dissolve Type" : 0 : "Particle effects to be generated when something is dissolved." =
	[
		0 : "Energy"
		1 : "Heavy electrical"
		2 : "Light electrical"
		3 : "Core Effect"
	]
	
	input Dissolve(string) : "Dissolve the specified target. If no target is passed, it will use the target specified in the Target to Dissolve field."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_entity_igniter") = env_entity_igniter : 
	"An entity that catches a target entity on fire."
[
	target(target_destination) : "Entity to Ignite" : : "Name of the entity to catch on fire."
	lifetime(integer) : "Lifetime" : 10 : "Duration of flames."
	
	input Ignite(void) : "Ignite the target entity."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_entity_maker") = env_entity_maker : 
	"Spawns the specified point_template at its origin. If set to auto-spawn, it will spawn the template whenever there is room and the player is looking elsewhere." 
[
	EntityTemplate(target_destination) : "point_template to Spawn" :  : "Name of the point_template to spawn here."

	PostSpawnSpeed(float) : "PostSpawn Movement Speed" : "0" : "If specified, all the entities created in the template will move this fast in the specified PostSpawn Movement Direction."
	PostSpawnDirection(angle) : "PostSpawn Movement Direction" : "0 0 0" : "If a PostSpawn Movement Speed is specified, all the entities created in the template will move in this direction."
	PostSpawnDirectionVariance(float) : "PostSpawn Direction Variance" : "0.15" : "This variance is applied to the PostSpawn Movement Direction for each spawned entity in the template. Use it to apply some randomness to the directions."
	PostSpawnInheritAngles(boolean) : "PostSpawn Inherit Angles?" : 0 : "If Yes, offset the spawn angles by the angles of a Parent."
	
	spawnflags(Flags) =
	[
		1 : "Enable AutoSpawn (will spawn whenever there's room)" : 0
		2 : "AutoSpawn: Wait for entity destruction" : 0
		4 : "AutoSpawn: Even if the player is looking" : 0
		8 : "ForceSpawn: Only if there's room" : 0
	  	16 : "ForceSpawn: Only if the player isn't looking" : 0
	]

	input ForceSpawn(void) : "Spawn an instance of the template at this origin and angle."
	input ForceSpawnAtEntityOrigin(target_destination) : "Spawn an instance of the template that the same origin and angle as the specified entity."

	output OnEntitySpawned(void) : "Fired when an instance of the entity template has been spawned."
	output OnEntityFailedSpawn(void) : "Fired when a ForceSpawn input failed to spawn the template, either due to lack of space or being in player's view, depending on the spawnflags."
]

@PointClass base(BaseEntityPoint) sphere(iRadiusOverride) iconsprite("editor-ficool2/env_explosion") = env_explosion : 
	"An entity that creates an explosion at its origin. Will not do damage when parented, use logic_measure_movement as a workaround for parenting." 
[
	iMagnitude(Integer) : "Magnitude" : 100 : "The amount of damage done by the explosion."
	iRadiusOverride(Integer) : "Radius Override" : : "If specified, the radius in which the explosion damages entities. If unspecified, the radius will be based on the magnitude."
	fireballsprite(sprite) : "Fireball Sprite" : "sprites/zerogxplode.spr" : "Sprite of the fireball."
	rendermode(choices) : "Render Mode" : 5 : "Render mode of the fireball." =
	[
		0: "Normal"
		1: "Color"
		2: "Texture"
		3: "Glow"
		4: "Solid/Alphatest"
		5: "Additive"
		7: "Additive Fractional Frame"
		8: "Alpha Add"
		9: "World Space Glow"
		10: "Don't Render"
	]

	ignoredEntity(target_destination) : "Ignored Entity" : : "Do not harm or affect the named entity."
	DamageForce(float) : "Damage Force" : : "Uncertain. Setting to a non-zero number weakens forces on physics objects."
	
	spawnflags(flags) =
	[
		1: "No Damage" : 0
		2: "Repeatable" : 1
		4: "No Fireball" : 0
		8: "No Smoke" : 0
		16: "No Decal" : 0
		32: "No Sparks" : 0
		64: "No Sound" : 0
		128: "Random Orientation for Explosion Sprite" : 0
		256: "No Fireball Smoke" : 0
		512: "No particles" : 0
		1024: "No Light" : 0
		2048: "Don't clamp sprite scale to >= 10" : 0
		4096: "Don't clamp sprite scale to <= 50" : 0
		8192: "Don't damage underwater objects" : 0
		16384: "Generic damage" : 0
	]
	
	input Explode(void) : "Triggers the explosion."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_fade") = env_fade : 
	"An entity that controls screen fades to or from a solid color. Add Duration and Hold Time together for the total time this entity will be in effect."
[
	duration(string) : "Duration (seconds)" : "2" : "The time that it will take to fade the screen in or out."
	holdtime(string) : "Hold Fade (seconds)" : "0" : "The time to hold the faded in/out state."
	renderamt(integer) : "Fade Alpha" : 255 : "Alpha of the fade, where 0 = fully transparent and 255 = fully opaque." 
	rendercolor(color255) : "Fade Color (R G B)" : "0 0 0"
	
	spawnflags(flags) =
	[
		1: "Fade From - Screen fades from the specified color instead of to it." : 0
		2: "Modulate - Uses attenuation blending for fades. Color of 0 255 0 would mute the red+blue channels = create nightvision effect." : 0
		4: "Triggering (!activator) player only" : 0
		8: "Stay Out - Fade remains indefinitely until another fade deactivates it." : 0
	]

	input Fade(void) : "Start the screen fade."
	input Color(color255) : "Changes Fade Color."
	input Alpha(integer) : "Changes Fade Alpha."
		
	output OnBeginFade(void) : "Fired when the fade has begun."
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/env_fire") = env_fire : 
	"An entity that handles a single flame at its origin. The flame causes heat 'damage' to other env_fire entities around it, and will eventually ignite non-flaming env_fire entities nearby, causing the fire to spread. Does not create any light."+
	"Note: Plasma fire is invisible."
[
	health(integer) : "Duration" : 30 : "Amount of time the fire will burn."
	firesize(integer) : "Size" : 64 : "Height (in world units) of the flame."
	fireattack(integer) : "Attack" : 4 : "Amount of time the fire takes to grow to full strength."
	firetype(choices) : "Type" : 0 =
	[
		0 : "Natural"
		1 : "Plasma (effects do not exist!)"
	]
	ignitionpoint(float) : "Ignition Point" : 32 : "Amount of heat 'damage' to take before this flame should ignite."
	damagescale(float) : "Damage Scale" : "1.0" : "Multiplier of the burn damage done by the flame."

	spawnflags(flags) =
	[
		1:	"Infinite Duration" : 0
		2:	"Smokeless" : 0
		4:	"Start On" : 0
		8:	"Start Full" : 0
		16:	"Don't drop" : 0
		32: 	"No glow" : 0
		128: 	"Delete when out" : 0
		256: 	"Visible from above" : 0
	]
	
	input StartFire(void) : "Start the fire."
	input Extinguish(float) : "Puts out the fire permanently in the number of seconds specified."
	input ExtinguishTemporary(float): "Puts out the fire temporarily in the number of seconds specified."

	output OnIgnited(void) : "Fires when the fire is first ignited."
	output OnExtinguished(void) : "Fires when the fire is fully extinguished."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_fire_trail") = env_fire_trail : 
	"An entity that creates a small fire trail. Recommended to be parented."
[
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_firesensor") sphere(fireradius) = env_firesensor : 
	"An entity that detects changes in heat nearby."
[
	fireradius(float) : "Radius" : 128 : "The radius around this entity in which to detect heat changes."
	heatlevel(float) : "Heat level" : 32 : "The target heat level to check for. Outputs are fired when the heat moves over this target level (increasing or decreasing)."
	heattime(float) : "Time at level" : 0 : "The amount of time the heat level must spend over the target level before the 'OnHeatLevelStart' output is fired."

	spawnflags(flags) =
	[
		1:	"Start On" : 1
	]
	
	input Enable(void) : "Enable the fire sensor."
	input Disable(void) : "Disable the fire sensor."

	output OnHeatLevelStart(void) : "Fires when the heat level has been sustained for the specified length of time."
	output OnHeatLevelEnd(void) : "Fires when the heat level drops below the target level."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_firesource") sphere(fireradius) = env_firesource : 
	"An entity that provides heat to all nearby env_fire entities. Cannot be extinguished."
[
	spawnflags(flags) =
	[
		1:	"Start On" : 0
	]

	fireradius(float) : "Radius" : 128 : "The radius around this entity in which to provide heat."
	firedamage(float) : "Intensity / Damage" : 10 : "Amount of heat 'damage' to apply to env_fire entities within the radius."

	input Enable(void) : "Enable fire source."
	input Disable(void) : "Disable fire source."
]

@PointClass base(BaseEntity, Angles) iconsprite("editor-ficool2/env_fog_controller") = env_fog_controller : 
	"An entity that controls the fog and view distance in the map. Fog may be changed per-player using the SetFogController input on them (requires an !activator)."
[
	fogenable(boolean) : "Fog enabled on start?" : 1 : "Make fog start active."
	fogstart(string) : "Fog Start" : "500.0" : "How far away from the viewer the fog should start."
	fogend(string) : "Fog End" : "2000.0" : "How far away from the viewer the fog reaches Fog Max Density."
	fogmaxdensity(float) : "Fog Max Density" : "1" : "Maximum density the fog may reach. Expressed as a decimal percent, so for 45% put 0.45."
	farz(string) : "Far Z Clip Plane (-1 = disable)" : "-1" : "Nothing but sky will be rendered beyond this distance from the camera."
	fogcolor(color255) : "Primary Fog Color" : "255 255 255" : "Primary Fog Color."
	fogcolor2(color255) : "Secondary Fog Color" : "255 255 255" : "Secondary Fog Color. If Fog Blend is disabled, this color will never appear."
	fogblend(boolean) : "Fog Blend?" : 0 : "Enables color blending between Primary Fog Color and Secondary Fog Color. When the viewer looks in the Primary Fog Direction, fog will appear as the Primary color. When looking away from the specified direction, fog appears as the Secondary color. If the camera is not pointed directly at or away from the direction, a blend of the two colors will result. Sunlight with a Yaw of 45 degrees and a Pitch of -45 degrees could be enhanced using a Primary Fog Direction of '-1 -1 1', a Primary Fog Color of '120 110 100' and a Secondary Fog Color of '80 70 60'."
	
	fogdir(string) : "Primary Fog Direction" : "1 0 0" : "A vector (given by three space-separated numbers X Y Z) which the viewer camera is checked against to figure out the blend between the primary and secondary fog colors."
	use_angles(boolean) : "Use Angles for Fog Direction?" : 0 : "Use Pitch Yaw Roll for the Fog Blend direction instead of Primary Fog Direction. There isn't much use for this unless you want the direction to rotate."
	
	foglerptime(float) : "Interpolate Time" : "0" : "Fade time for the StartFogTransition input, in seconds."
	
	spawnflags(flags) =
	[
		1 : "Master - If multiple env_fog_controllers are active, this one will always take priority." : 0
	]

	input TurnOn(void) : "Turn the fog on."
	input TurnOff(void) : "Turn the fog off."
	input SetStartDist(float) : "Set the Fog Start distance."
	input SetEndDist(float) : "Set the Fog End distance."
	input SetColor(color255) : "Sets the Primary Fog Color."
	input SetColorSecondary(color255) : "Sets the Secondary Fog Color."
	input SetFarZ(integer): "Sets the Far Z Clip Plane distance."
	input SetAngles(string) : "Sets the angles to use for the Primary Fog Direction."

	input SetColorLerpTo(color255) : "Stores a value for Primary Fog Color that is set once the StartFogTransition input fires."
	input SetColorSecondaryLerpTo(color255) : "Stores a value for Secondary Fog Color that is set once the StartFogTransition input fires."
	input SetStartDistLerpTo(float) : "Stores a value for Fog Start that is set once the StartFogTransition input fires."
	input SetEndDistLerpTo(float) : "Stores a value for Fog End that is set once the StartFogTransition input fires."
	input StartFogTransition(void) : "When fired, the fog fades to any new values sent through the 'LerpTo' inputs. Fade time is determined by the Interpolate time keyvalue."
	
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_funnel") = env_funnel : 
	"Half-Life legacy entity: Creates many sprites which move toward a point (or from a point). The sprite is hardcoded to be sprites/flare6.vmt, but this texture is missing by default. This entity must be activated with the Use input. After it has been Used, it is deleted from the map." 
[
	spawnflags(flags) =
	[
		1: "Reverse - Funnel repels sprites instead of attracting them." : 0
	]

	input Use(void) : "Triggers the effect."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_global") = env_global : 
	"An entity to control a game-specific global states."
[
	globalstate(choices) : "Global State to Set" : : "The global state this entity is linked to. Some or all states may not function." =
	[
		"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"
		"ep2_alyx_injured" : "Episode 2: Alyx injured"
		"ep_alyx_darknessmode" : "Episodic: Alyx darkness mode"
		"hunters_to_run_over" : "Episode 2 Counter: Hunters to run over before they dodge"
	]
	initialstate(choices) : "Initial State" : 0 =
	[
		0 : "Off"
		1 : "On"
		2 : "Dead"
	]
	counter(integer) : "Counter" : 0 : "An integer counter value associated with this global."

	spawnflags(flags) =
	[
		1 : "Set Initial State - Whether this entity defines the global state when the map starts." : 0
	]

	input TurnOn(void) : "Set state of global to ON."
	input TurnOff(void) : "Set state of global to OFF."
	input Toggle(void) : "Toggles state of global between ON and OFF."
	input Remove(void) : "Set state of global to DEAD."
	input SetCounter(integer) : "Sets the counter value of this global."
	input AddToCounter(integer) : "Adds to the counter value of this global. Negative numbers subtract."
	input GetCounter(void) : "Fires this entity's Counter output."

	output Counter(integer) : "Outputs the integer value of this entity. May depend on global state."
]

@PointClass base(BaseEntityPoint, Render) size(-2 -2 -2, 2 2 2) sprite() color(20 140 20) = env_glow : 
	"Identical to env_sprite. An entity that controls the drawing of a sprite in the world." 
[
	model(sprite) : "Sprite Name" : "sprites/glow01.spr" : "Material of the sprite to be drawn."
	frame(integer) : "Starting Frame" : 0 : "If the sprite is animated, the frame it should start animating on."
	framerate(float) : "Framerate" : "10.0" : "Rate at which the sprite should animate, if at all."
	scale(float) : "Scale" : "0.25" : "Scale multiplier of the sprite."
	GlowProxySize(float) : "Size of Glow Proxy Geometry." : "2.0" : "Size of the glow to be rendered for visibility testing. Must be larger than the distance from the sprite center to empty space.  So if this glow is inside geometry (like a light bulb), set this value to be bigger than the bulb's radius. Any time a sphere of this radius would be visible (poking through any nearby geometry), the glow will be rendered."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Color multiplier for players using HDR."
	
	spawnflags(flags) =
	[
		1: "Start On" : 1
		2: "Play Once - Used for animated sprites. Texture will animate once, then the sprite will turn off." : 0
	]
	
	input HideSprite(void) : "Hide the sprite. Won't be drawn until the 'ShowSprite' input is received."
	input ShowSprite(void) : "Show the sprite."
	input ToggleSprite(void) : "Toggle the sprite between hidden and shown."
	input ColorRedValue(float) : "Sets the red color channel's value (0 - 255)."
	input ColorGreenValue(float) : "Sets the green color channel's value (0 - 255)."
	input ColorBlueValue(float) : "Sets the blue color channel's value (0 - 255)."
	input SetScale(float) : "Set the sprite's scale."
]

@PointClass base(BaseEntityPoint, EnableDisable) line(255 255 255, targetname, target)  iconsprite("editor-ficool2/env_gunfire") = env_gunfire : 
    "This entity creates a gunfire effect which can be dynamically controlled and pointed at a target, to give the illusion of a weapon firing without an actual weapon entity being used. The visual effect will be identical to an actual weapon firing, but causes no damage."
[
	target(target_destination) : "Target" :  : "The target to shoot at."

	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, in seconds."
	maxburstdelay(float) : "Max Delay between Bursts" : 5 : "Maximum delay between bursts, in 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." =
	[
		0 : "Perfect accuracy"
		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(sound) : "Shoot Sound" :  : "Sound to make when firing. Must be a soundscript and not a raw filename. A list of suitable gunfire sounds is usually found in scripts/game_sounds_weapons.txt"

	tracertype(string) : "Tracer" :  : "Type of tracer to display. See the bottom of ficool2_tf2.fgd (Special Effects) for a list."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_hudhint") = env_hudhint : 
	"An entity to control the display of HUD hints. HUD hints are used to show the player what key is bound to a particular command."
[																																												
	message(string) : "Hint Text" :  : "This should be set to match the desired HUD hint entry in the resource\<game>_english.txt. Unlocalized (raw) text can still be used if needed."
	spawnflags(flags) =
	[
		1: "All Players - otherwise only activating player" : 0
	]
	input ShowHudHint(void) : "Shows the hint message."
	input HideHudHint(void) : "Hides the hint message."
]

@PointClass base(env_beam) iconsprite("editor-ficool2/env_laser") line(255 255 255, targetname, LaserTarget) = env_laser : 
	"Note: this entity inherits from env_beam. Not all keyvalues/inputs/flags may work. "+
	"An entity that creates a laser beam between itself and a given target. The main difference between this entity and env_beam is that a laser will not travel through anything solid."
[
	LaserTarget(target_destination) : "Target of Laser" : : "Name of entity, or entities, to strike at. The target is randomly chosen if there are multiple entities matching the given name."
	width(float) : "Width of laser" : 2 : "The width of the laser laser, in pixels."
	framestart(integer) : "Starting Frame" : 0 : "The frame to start the laser texture on."
	EndSprite(sprite) : "End Sprite" :  : "If specified, this sprite will be drawn at the end of the laser."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Value to multiply laser color by when running in HDR mode."
	
	damage(string) : "Damage / second" : "0" : "How much damage this laser does. per second. to things it hits."
	dissolvetype(choices) : "Dissolve Type" : "-1" : "If this laser damages and kills something, effects to show around the object. " =
	[
		-1 : "None"
		0 : "Energy"
		1 : "Heavy electrical"
		2 : "Light electrical"
	]

	spawnflags(flags) = 
	[
		1 : "Start On" : 0
		2 : "Toggle - Obsolete, replaced by the Toggle input." : 0
		4 : "Random Strike - When the beam has died, it will strike again randomly within the time set by Strike again time (secs)." : 0
		8 : "Ring - Uses the starting and ending points as a diameter, drawing a beam ring between them instead of a straight line." : 0
		16: "StartSparks - Every time the beam strikes or is turned on, the beam emits a small shower of sparks at its Start Entity." : 0
		32: "EndSparks - Every time the beam strikes or is turned on, the beam emits a small shower of sparks at its Ending Entity." : 0
		64: "Decal End - Places a decal scorch mark where a damaging beam hits the first solid object (world brush or entity)." : 0
		128: "Shade Start - Fades out toward its Start Entity. Overrides Shade End. Does not work on striking beams or beam rings." : 0
		256: "Shade End - Fades out toward its Ending Entity. Is overridden by Shade Start. Does not work on striking beams or beam rings." : 0
		512: "Taper Out - Taper out into a point towards its Ending Entity. Does not work on striking beams or beam rings." : 0
	]
	
	input TurnOn(void) : "Turns the laser on."
	input TurnOff(void) : "Turns the laser off."
	input Toggle(void) : "Toggles the laser between on and off."
	
	input ColorRedValue(float) : "Sets the red color channel's value (0 - 255)."
	input ColorGreenValue(float) : "Sets the green color channel's value (0 - 255)."
	input ColorBlueValue(float) : "Sets the blue color channel's value (0 - 255)."
	input Noise(float) : "Set how far away from the middle the laser is allowed to deviate. (0 - 64)"
	input ScrollSpeed(float) : "Set the scroll speed in units per second (0 - 100)."
	input Width(float) : "Set the width of the laser, in pixels. (1 - 25.5) "
]





@PointClass base(BaseEntityPoint) size(-2 -2 -2, 2 2 2) sprite("sprites/light_glow01") = env_lightglow : 
	"An entity that puts an additive glow in the world, mostly used over light sources."
[
	rendercolor(color255) : "Color (R G B)" : "255 255 255" : "Glow color."
	VerticalGlowSize(integer) : "Vertical Size" : 30 : "Vertical glow size in units."
	HorizontalGlowSize(integer) : "Horizontal Size" : 30 : "Horizontal glow size in units."
	MinDist(integer) : "Minimum Distance" : 500 : "The distance at which this effect will be fully translucent."
	MaxDist(integer) : "Maximum Distance" : 2000 : "The distance at which this effect will be at full intensity."
	OuterMaxDist(integer) : "Outer Maximum Distance" : 0 : "If larger than the maximum distance, this is the length at which the glow will fade completely out, between the span of the maximum distance and this length."
	GlowProxySize(float) : "Glow Proxy Geometry Size" : "2.0" : "Size of the glow to be rendered for visibility testing. Must be larger than the distance from the sprite center to empty space. So if this glow is inside geometry (like a light bulb), set this value to be bigger than the bulb's radius. Any time a sphere of this radius would be visible (poking through any nearby geometry), the glow will be rendered."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Color multiplier for players using HDR."

	spawnflags(flags) =
	[
		1: "Visible only from front" : 0
	]
	
	input Color(color255) : "Change the color of the glow. A value of 0 0 0 will hide the sprite."

]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_message") = env_message : 
	"An entity that draws a text message on player's HUDs."
[
	message(choices) : "Message Text" : : "Message to be shown." =
	[
		"CR1" : "Testing 1"
		"CR2" : "Testing 2"
		"CR3" : "Testing 3"
		"GAMEOVER_ALLY" : "FAILURE TO PRESERVE MISSION-CRITICAL PERSONNEL"
		"GAMEOVER_OBJECT" : "FAILURE TO PRESERVE MISSION-CRITICAL RESOURCE"
		"GAMEOVER_TIMER" : "FAILURE TO PREVENT TIME-CRITICAL SEQUENCE "
		"GAMEOVER_STUCK" : "DEMONSTRATION OF EXCEEDINGLY POOR JUDGMENT"
		"CHAPTER1_TITLE" : "POINT INSERTION "
		"CHAPTER2_TITLE" : "A RED LETTER DAY"
		"CHAPTER3_TITLE" : "ROUTE KANAL"
		"CHAPTER4_TITLE" : "WATER HAZARD "
		"CHAPTER5_TITLE" : "BLACK MESA EAST"
		"CHAPTER6_TITLE" : "WE DON'T GO TO RAVENHOLM..."
		"CHAPTER7_TITLE" : "HIGHWAY 17"
		"CHAPTER8_TITLE" : "SANDTRAPS"
		"CHAPTER9_TITLE" : "NOVA PROSPEKT"
		"CHAPTER9A_TITLE" : "ENTANGLEMENT"
		"CHAPTER10_TITLE" : "ANTICITIZEN ONE"
		"CHAPTER11_TITLE" : "FOLLOW FREEMAN!"
		"CHAPTER12_TITLE" : "OUR BENEFACTORS"
		"CHAPTER13_TITLE": "DARK ENERGY "
		"GAMESAVED" : "Saved..."
		"GAMETITLE" : "Half-Life"
	]
	
	messagesound(sound) : "Sound Effect" :  : "When the message is shown, this sound effect will be played, originating from this entity."
	messagevolume(string) : "Volume 0-10" : "10" : "Volume of the sound effect."
	messageattenuation(Choices) : "Sound Radius" : 0 =
	[
		0 : "Small Radius"
		1 : "Medium Radius"
		2 : "Large  Radius"
		3 : "Play Everywhere"
	]
	
	spawnflags(flags) =
	[
		1: "Play Once" : 0
		2: "All Clients - otherwise activating player only" : 0
	]
	
	input ShowMessage(void) : "Shows the message and plays the sound."
	
	output OnShowMessage(void) : "Fired when the message is activated."
]

@PointClass base(BaseEntityPoint, EnableDisable) sphere(MaxRange) iconsprite("editor/env_microphone") = env_microphone :
	"An entity that acts as a microphone. It works in one of two modes. If it has a 'Speaker' set, it picks up all sounds within the specified sound range, " +
	"and rebroadcasts them through the Speaker entity. In this Speaker mode, it ignores the Hears X spawnflags and does not fire the SoundLevel output. " +
	"If it has no Speaker set, it measures the sound level at a point, and outputs the sound level as a value between 0 and 1. In Measuring mode, it only hears sounds that match the Hear X spawnflags."
[
	target(target_destination) : "Measure target" : : "If the speaker is in Measuring mode, this is the name of the entity where the sound level is to be measured."
	SpeakerName(target_destination) : "Speaker target" :  : "The name of an info_target entity through which to play any sounds heard by this microphone. Can be another env_microphone. If specified, the microphone will consider itself in Speaker mode."
	ListenFilter(filterclass) : "Listen Filter" :  : "The name of an filter entity which specifies the only entities the microphone can hear. Sounds emitted by other entities will not be heard."
	speaker_dsp_preset(choices) : "Speaker DSP Preset" : 0 : "Only useful in Speaker mode. If specified, when the microphone is enabled, it'll set the global dsp_speaker preset to this value. Sounds played back through speakers will then be affected by the selected DSP. Only one env_microphone can have a DSP Preset active." =
	[
 		0 : "Use environment default"
		50 : "No effect"
		55 : "Loud speaker"
		56 : "Very small speaker"
		57 : "Echoing speaker"
		58 : "Small speaker"
		59 : "Tiny speaker"
	]

	Sensitivity(float) : "Sensitivity (0 - 10)" : 1 : "Microphone sensitivity, 0=deaf, 1=default, 10=extremely sensitive). Only applicable in Measuring mode."
	SmoothFactor(float) : "Smoothing (0 - 1)" : 0 : "Smoothing factor, 0=no smoothing, 1=maximum smoothing). Only applicable in Measuring mode."
	MaxRange(float) : "Maximum hearing range (0=infinite)" : 240 : "Sounds beyond this range won't be heard, irrelevant of attenuation. "+
		"Warning: setting this to zero (or a value > 1024) when the microphone is in Speaker mode can be very bad for performance!"
	SoundMask(integer) : "Sound Mask" : 0 : "Unknown function. Possible alternative to the Hears X spawnflags."
	
	spawnflags(flags) =
	[
		1 : "Hears combat sounds" : 1
		2 : "Hears world sounds" : 1
		4 : "Hears player sounds" : 1
		8 : "Hears bullet impacts" : 1
		16: "Swallows sounds routed through speakers - Does not listen to sounds coming though from any other microphone including itself" : 0
		32: "Hears explosions" : 0
		64: "Ignores non-attenuated sounds" : 0
	]
	
	input SetSpeakerName(string) : "Set the microphone to output through a different speaker entity."

	output SoundLevel(float) : "Fired in Measuring mode whenever the sound level changes."
	output OnRoutedSound(void) : "Fired whenever a sound is routed out through the specified speaker (if any)."
	output OnHeardSound(void) : "Fired whenever this microphone hears any sound it cares about."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_movieexplosion") = env_movieexplosion : 
	"An entity that creates a small cartoonic bubbles explosion lasting for 5 seconds."
[
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_muzzleflash") = env_muzzleflash : 
    "An entity that creates the effect of flames leaving a guns barrel when firing." 
[
	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(BaseEntity) iconsprite("editor-ficool2/env_particle_performance_monitor") = env_particle_performance_monitor : 
	"An entity for turning on and off measuring and display of particle throughput."
[
	input TurnOnDisplay(void) : "Turn on display of particle simulation benchmark."
	input TurnOffDisplay(void) : "Turn off display of particle simulation benchmark."
	input StartMeasuring(void) : "Start measuring particle simulation speed."
	input StopMeasuring(void) : "Stop measuring particle simulation speed."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_particle_trail") = env_particle_trail : 
	"An entity which emits a particle trail. Becomes visible when parented to an object, and then emits particle trails from the entity's bounding box."
[
	ParticleTrailMaterial(material) : "Particle Trail Material" : : "Name of a material to use for the 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 particles to emit."
	ParticleTrailEndSize(float) : "Particle Trail Ending Sprite Size" : 3 : "Ending size of the particles to emit."
]


@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_particlelight") = env_particlelight : 
	"An entity that can be used to light the particles emitted by env_smokestack entities. Does not light any other particle types."
[
	Color(color255) : "Color" : "255 0 0" : "Color emitted by this light." 
	Intensity(integer) : "Intensity" : 5000 : "How strong the light is."

	directional(boolean) : "Directional?" : 0 : "If this is specified, then this light will use the bump map on the particles. Each particle system can have one ambient and one directional light."

	PSName(string) : "Particle System Entity" :  : "Set this to the name of the env_smokestack that you want this light to affect."
]

@PointClass base(BaseAnimating) studioprop() = env_particlescript : 
	"An entity that has special animation events that can be fired by a model with an animation inside its .QC designed for use by this entity."
[
	model(studio) : "Script Model" : "models/Ambient_citadel_paths.mdl" : "Model to use for animation sequences."

	input SetSequence(string) : "Sets the script model's sequence."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_particlesmokegrenade") = env_particlesmokegrenade : 
	"An entity that emits a tiny puff of smoke when spawned."
[
]

@PointClass base(BaseEntityPoint) sphere(radius) sphere(inner_radius) iconsprite("editor-ficool2/env_physexplosion") = env_physexplosion : 
	"An entity that creates an explosion at its origin. If the no-damage spawnflag is set, the explosion won't be visible, but will apply force to any physics objects within its radius."
[
	magnitude(string) : "Magnitude (0 - 100)" : "100" : "Amount of physics force applied by the explosion."
	radius(string) : "Clamp Radius (0 = auto)" : "0" : "If specified, the radius in which the explosion damages entities. If unspecified, the radius will be based on the magnitude."
	targetentityname(target_destination) : "Limit to Entity" :  : "If specified, the explosion will only affect the matching entity."
	inner_radius(float) : "Inner radius" : "0" : "If not zero, the LOS is calculated from a point intersecting this sphere."
	
	spawnflags(flags) =
	[
		1 : "No Damage - Only Force" : 1
		2 : "Push players" : 0
		4 : "Push radially - not as a sphere (Radially meaning as a circle/cylinder. No upward or downward force will be generated.)" : 0
		8 : "Test LOS before pushing" : 0
		16 : "Disorient player if pushed" : 0
	]

	input Explode(void) : "Trigger the explosion."
	
	output OnPushedPlayer(void) : "Fires when the player is pushed by the explosion."
]

@PointClass base(BaseEntityPoint) sphere(distance) line(255 255 255, targetname, directionentityname) iconsprite("editor-ficool2/env_physimpact") = env_physimpact : 
	"An entity that will cause a physics impact on another entity. Does not function in Team Fortress 2."
[
	angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "Direction to project the impact."
	magnitude(integer) : "Magnitude" : 100 : "Strength of the impact."
	distance(integer) : "Distance" : 0 : "How far to project the impact (if 0 uses a default value)."
	directionentityname(target_destination) : "Point to Entity" :  : "If set, 'Distance' and Angle settings are ignored and the direction and distance to the target entity will be used."

	spawnflags(flags) =
	[
		1: "No fall-off" : 0
		2: "Infinite Length" : 0
		4: "Ignore Mass" : 0
		8: "Ignore Surface Normal When Applying Force" : 1
	]

	input Impact(void) : "Trigger the impact."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_player_surface_trigger") = env_player_surface_trigger : 
	"An entity that monitors the material of the surface the player is standing on, and fires outputs whenever it changes to/from a specific material."
[
	gamematerial(choices) : "Game Material to Watch" : "0" : "The material to watch. When the player stands on/off this material, this entity's outputs will be fired." =
	[
		0 : "None (player's in the air)"
		67 : "Concrete"
		68 : "Dirt"
		70 : "Flesh"
		71 : "Grate"
		73 : "Clip"
		77 : "Metal"
		78 : "Sand"
		79 : "Foliage"
		80 : "Computer"
		83 : "Slosh"
		84 : "Tile"
		86 : "Vent"
		87 : "Wood"
		89 : "Glass"
	]
	
	input Enable(void) : "Start watching the player's surface."
	input Disable(void) : "Stop watching the player's surface."

	output OnSurfaceChangedToTarget(void) : "Fired when the player moves onto the specified game material."
	output OnSurfaceChangedFromTarget(void) : "Fired when the player moves off the specified game material."
]

@PointClass base(BaseEntityPoint) lightprop("models/editor/spot.mdl") frustum(lightfov,nearz,farz,lightcolor,-1) = env_projectedtexture : 
	"It projects a texture as a dynamic light that affects all objects in the world, optionally with shadow mapping. Only 1 instance of this entity can be enabled. Disabled in Team Fortress 2 by default, requires mp_flashlight 1 to be enabled to function."
[
	target(target_destination)	: "Target" : : "The entity will rotate to point at this target. Make sure you check the 'Always Update' flag if you set this."	
	
	dontfollowtarget(Choices) : "Don't Follow Target" : 0 : "Prevents this entity from trying to point at its target, if it has one. Intended for when you want to use 'Light Only Target' without the entity trying to point to it." =
	[
		0 : "No"
		1 : "Yes"
	]
	
	lightfov(float)				: "FOV" : "90.0" : "The field of view cone/pyramid at which the texture is projected. Can also be interpreted as 'size'."
	lighthorfov(float)				: "Horizontal FOV" : "0" : "The horizontal FOV value. This allows the projected texture to use rectangular dimensions, but it causes shadow glitches and is usually not preferable unless shadows are disabled. Leave this at 0 if you want to keep this the same as the regular FOV value."
	nearz(float)				: "NearZ" : "4.0" : "Objects closer than this will not receive the light from the projection. (Warning: Hard falloff, model lighting inconsistent)"
	farz(float)					: "FarZ" : "750.0" : "Objects beyond this distance will not receive the light from the projection. The projection fades out as it approaches this distance."	
	
	enableshadows(Choices) : "Enable Shadows" : 1 : "Enables/disables shadows from this projected texture." =
	[
		0 : "No"
		1 : "Yes"
	]
	shadowquality(Choices) : "Shadow Quality" : 1 : "Quality of shadows." =
	[
		0 : "Low"
		1 : "High"
	]
	
	lightonlytarget(Choices) : "Light Only Target" : 0 : "Limit flashlight effect to only effect target entity." =
	[
		0 : "No"
		1 : "Yes"
	]
	lightworld(Choices) : "Light World" : 1 : "Control whether flashlight effects static world geometry." =
	[
		0 : "No"
		1 : "Yes"
	]
	
	brightnessscale(float)		: "Brightness Scale" : "1.0" : "The light color's brightness scale."	

	lightcolor(color255)		: "Light Color" : "255 255 255 200" : "The color of the projected texture. Format is RGB-Intensity, like a light entity. Intensity can only range from 0 to 255, so use the Brightness Scale keyvalue to make the projected texture brighter than 255."
	colortransitiontime(float)	: "Color Transition Time" : "0" : "Amount of time it takes for a color or brightness change to occur. 0 = instant"
	cameraspace(Choices)		: "Camera Space" : 0 : "Angles are interpreted as being relative to camera." =
	[
		0 : "No"
		1 : "Yes"
	]

	texturename(material) : "Texture Name" : "effects/flashlight001"
	textureframe(integer) : "Texture Frame" : 0 : "Sets the frame of the projected texture. Only relevant if the texture is animated/has multiple frames."
	
	alwaysdraw(Choices)		: "Always Draw" : 0 : "Always draws the projected texture, regardless of whether the player can see its frustum. Use this for projected textures that can be seen on monitors or in the skybox." =
	[
		0 : "No"
		1 : "Yes"
	]
	
	ProjectedTextureVersion(integer)	readonly	: "Projected Texture Version"	: 1  : "(Don't change). Differentiates between projected textures built before/outside of Mapbase and projected textures using new features."
	
	spawnflags(flags) =
	[
		1  : "Enabled"				: 1
		2  : "Always Update (moving light)"	: 0
	]

	input TurnOn(void)		: "Turns on the texture"
	input TurnOff(void)		: "Turns off the texture"
	input AlwaysUpdateOn(void)	: "Turns on per frame updating (for moving lights)"
	input AlwaysUpdateOff(void)	: "Turns off per frame updating (for moving lights)"
	input FOV(float)		: "Sets the FOV."
	input VerFOV(float)		: "Sets the vertical FOV."
	input HorFOV(float)		: "Sets the horizontal FOV."
	input SpotlightTexture(string)		: "Sets the spotlight texture"
	input SetSpotlightFrame(string)		: "Sets the spotlight texture frame"
	input EnableShadows(bool)		: "Set the if shadows are enabled"
	input LightColor(color255)		: "Change the light color"
	input SetBrightness(float)		: "Sets brightness."
	input SetColorTransitionTime(float)		: "Sets the color transition time."
	input SetNearZ(float)		: "Sets NearZ."
	input SetFarZ(float)		: "Sets FarZ."
	input AlwaysDrawOn(void)	: "Turns off BBox culling (for skybox or monitor lights)"
	input AlwaysDrawOff(void)	: "Turns on BBox culling if it was off before"
	input StopFollowingTarget(void)	: "Causes this entity to stop following the target, if it has one"
	input StartFollowingTarget(void)	: "Causes this entity to start following the target if it was set to not follow it before"
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_rockettrail") = env_rockettrail : 
	"An entity that emits a rocket trail."
[
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_screenoverlay") = env_screenoverlay: 
	"An entity that can display and control a set of screen overlays, to be displayed over the player's view. Useful for view effects like drunkenness, or teleporter afterimages, etc."
[
	OverlayName1(material) : "Overlay Name 1" :  : "Name of the first overlay material to display."
	OverlayTime1(float) : "Overlay Duration 1" : "1.0" : "Amount of time that the first overlay should be displayed for, after which it will begin showing the second overlay.  Use -1 for a permanent display."
	OverlayName2(material) : "Overlay Name 2" :  : "Name of the second overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime2(float) : "Overlay Duration 2" : "1.0" : "Amount of time that the second overlay should be displayed for, after which it will begin showing the third overlay.  Use -1 for a permanent display."
	OverlayName3(material) : "Overlay Name 3" :  : "Name of the third overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime3(float) : "Overlay Duration 3" : "1.0" : "Amount of time that the third overlay should be displayed for, after which it will begin showing the fourth overlay.  Use -1 for a permanent display."
	OverlayName4(material) : "Overlay Name 4" :  : "Name of the fourth overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime4(float) : "Overlay Duration 4" : "1.0" : "Amount of time that the fourth overlay should be displayed for, after which it will begin showing the fifth overlay.  Use -1 for a permanent display."
	OverlayName5(material) : "Overlay Name 5" :  : "Name of the fifth overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime5(float) : "Overlay Duration 5" : "1.0" : "Amount of time that the fifth overlay should be displayed for, after which it will begin showing the sixth overlay.  Use -1 for a permanent display."
	OverlayName6(material) : "Overlay Name 6" :  : "Name of the sixth overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime6(float) : "Overlay Duration 6" : "1.0" : "Amount of time that the sixth overlay should be displayed for, after which it will begin showing the seventh overlay.  Use -1 for a permanent display."
	OverlayName7(material) : "Overlay Name 7" :  : "Name of the seventh overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime7(float) : "Overlay Duration 7" : "1.0" : "Amount of time that the seventh overlay should be displayed for, after which it will begin showing the eighth overlay.  Use -1 for a permanent display."
	OverlayName8(material) : "Overlay Name 8" :  : "Name of the eighth overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime8(float) : "Overlay Duration 8" : "1.0" : "Amount of time that the eighth overlay should be displayed for, after which it will begin showing the ninth overlay.  Use -1 for a permanent display."
	OverlayName9(material) : "Overlay Name 9" :  : "Name of the ninth overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime9(float) : "Overlay Duration 9" : "1.0" : "Amount of time that the ninth overlay should be displayed for, after which it will begin showing the tenth overlay.  Use -1 for a permanent display."
	OverlayName10(material) : "Overlay Name 10" :  : "Name of the tenth overlay material to display. If left blank, overlay displaying will finish, and this entity will consider itself done."
	OverlayTime10(float) : "Overlay Duration 10" : "1.0" : "Amount of time that the tenth overlay should be displayed for, after which this entity will stop displaying overlays.  Use -1 for a permanent display."

	spawnflags(flags) =
	[
		1: "Allow Suit Zoom" : 0
	]
	
	input	StartOverlays(void) : "Start displaying the first overlay."
	input	StopOverlays(void) : "Stop displaying any overlays."
	input	SwitchOverlay(float) : "Switch to displaying a specific overlay. Pass in the desired overlay number in the parameter. Entering -1 as the value will cause the overlay to display indefinitely."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_shake") = env_shake : 
	"An entity which can be used to control screen shake on players or shake certain objects." 
[
	spawnflags(flags) =
	[
		1: "Shake globally" : 1
		2: "Disrupt player control" : 0
		4: "Shake players in air" : 1
		8: "Shake physic objects" : 1	
		16: "Shake ropes" : 1		
		32: "DON'T shake players" : 0
		64: "DON'T rumble controller" : 0
	]

	amplitude(float) : "Amplitude (0-16)" : "4" : "The amount of noise in the screen shake. Should be a range between 0 and 16."
	radius(float) : "Effect Radius" : "500" : "The radius around this entity in which to affect players."
	duration(float) : "Duration (seconds)" : "1" : "The length of time in which to shake the player's screens."
	frequency(float) : "Frequency" : "2.5" : "The frequency used to apply the screen shake. Should be a value between 0 and 255, where 0.1 = jerk, and 255.0 = rumble."

	input Amplitude(string) : "Set the amplitude (0-16)"
	input Frequency(string) : "Set the frequence. Should be a value between 0 and 255, where 0.1 = jerk, and 255.0 = rumble."
	input StartShake(void) : "Start the shake."
	input StopShake(void) : "Stop the shake."
]

@PointClass base(env_shooter_base) iconsprite("editor-ficool2/env_shooter") = env_shooter : 
	"An entity that shoots sprites, physically simulated objects or ragdolls out of its origin."
[
]

@PointClass base(BaseEntityPoint, Render) studioprop("models/editor/axis_helper.mdl") = env_smokestack : 
	"An entity that spits out a constant stream of particles. You can place up to two env_particlelight entities near the smoke stack to add ambient light to its particles."
[
	InitialState(choices) : "Initial State" : 0 = 
	[
		0 : "Off"
		1 : "On"
	]

	BaseSpread(integer) : "Spread at the base" : 20 : "Amount of random spread in the origins of the smoke particles when they're spawned."
	SpreadSpeed(integer) : "Spread Speed" : 15 : "Amount of random spread in the velocity of the smoke particles after they're spawned."
	Speed(integer) : "Speed" : 30 : "The speed at which the smoke particles move after they're spawned."
	StartSize(integer) : "Particle start size" : 20 : "Size of the smoke particles when they're first emitted."
	EndSize(integer) : "Particle end size" : 30 : "Size of the smoke particles at the point they fade out completely."
	Rate(integer) : "Emission rate" : 20 : "Rate at which to emit smoke particles (i.e. particles to emit per second)."
	JetLength(integer) : "Length of smoke trail" : 180 : "Length of the smokestack. Lifetime of the smoke particles is derived from this & particle speed."
	WindAngle(integer) : "Wind X/Y Angle" : 0 : "This specifies the wind direction. It is an angle in the XY plane. WindSpeed specifies the strength of the wind."
	WindSpeed(integer) : "Wind Speed" : 0 : "The strength of the wind."
	SmokeMaterial(material) : "Particle material" : "particle/SmokeStack.vmt" : "Material of the smoke particles emitted by this stack."
	twist(integer) : "Twist" : 0 : "The amount, in degrees per second, that the smoke particles twist around the origin."
	roll(float)			: "Roll Speed": 0 : "Amount of roll in degrees per second."
	
	rendercolor(color255)	: "Color (R G B)" : "255 255 255" : "The color of the smoke particles before particle lighting is applied."
	renderamt(integer)		: "Translucency (0 - 255)" : 255 : "The alpha translucency of the smoke particles.  0 is transparent; 255 is the material's normal opacity."
	
	input TurnOn(void) : "Turn on the smokestack."
	input TurnOff(void) : "Turn off the smokestack."
	input Toggle(void) : "Toggles the smokestack between on and off state."
	input JetLength(integer): "Set the length of the smoke trail."
	input Rate(integer) : "Set the rate at which to emit smoke particles (particles per second)."
	input Speed(integer) : "Set the speed at which the smoke particles move after they're spawned."
	input SpreadSpeed(integer) : "Set the amount of random spread in the velocity of the smoke particles after they're spawned."
	input Color(color255) : "Changes the smoke particle color."
	input Alpha(integer) : "Changes the smoke particle translucency."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_smoketrail") sphere(spawnradius) = env_smoketrail : 
	"An entity that creates a smoke trail. Must be parented to take effect." 
[
	opacity(float) : "Sprite Opacity" : "0.75" : "Opacity of the sprites (range from 0 - 1)."
	spawnrate(float) : "Spawn Rate" : "20" : "Number of particles to emit each second."
	lifetime(float) : "Particle Life Time" : "5.0" : "Number of seconds until each particle dies."
	startcolor(color255) : "Start Color" : "192 192 192" : "Starting color of the emitted particles."
	endcolor(color255) : "End Color" : "160 160 160" : "Ending color of the emitted particles."
	emittime(float) : "Emitter Life Time" : "0" : "Number of seconds until the env_smoketrail stops emitting particles. 0 means never stop emitting particles."
	minspeed(float) : "Minimum Random Speed" : "10" : "Minimum randomly-directed speed to use for emitted particles."
	maxspeed(float) : "Maximum Random Speed" : "20" : "Maximum randomly-directed speed to use for emitted particles."
	mindirectedspeed(float) : "Minimum Directed Speed" : "0" : "Minimum speed along the env_smoketrail's forward direction (x axis) to use for emitted particles."
	maxdirectedspeed(float) : "Maximum Directed Speed" : "0" : "Maximum speed along the env_smoketrail's forward direction (x axis) to use for emitted particles."
	startsize(float) : "Starting particle size" : "15" : "Starting particle size."
	endsize(float) : "Ending particle size" : "50" : "Ending particle size."
	spawnradius(float) : "Spawn radius" : "15" : "Distance from env_smoketrail at which particles are emitted."
]


@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_soundscape") sphere(radius) line(255 255 255, targetname, position0) line(255 255 255, targetname, position1) line(255 255 255, targetname, position2) line(255 255 255, targetname, position3) line(255 255 255, targetname, position4) line(255 255 255, targetname, position5) line(255 255 255, targetname, position6) line(255 255 255, targetname, position7) = env_soundscape : 
	"An entity to control sound in an area. The active soundscape at any time is the last one that had line-of-sight to the player, and was within the radius."
[
    // up to date as of 04/01/2019
	soundscape(choices) : "Soundscape" : "tf2.general_ambient" : "The name of the soundscape to use. Corresponds to an entry in the soundscapes*.txt file in the scripts directory." =
	[
		"tf2.general_ambient" : "General Ambience"
		"tf2.respawn_room" : "Respawn Room"
		"2fort.Underground" : "2Fort Underground"
		"2fort.Underground2" : "2Fort Underground2"
		"2fort.OutdoorPond" : "2Fort Outdoor Pond"
		"2fort.OutdoorFort" : "2Fort Outdoor Fort"
		"2fort.Indoor" : "2Fort Indoors"
		"Badlands.Inside" : "Badlands Inside"
		"Badlands.Outside" : "Badland Outside"
		"Badlands.OutsideInterior" : "Badlands Outside Interior"
		"barnblitz.inside" : "Barnblitz Inside"
		"barnblitz.outside" : "Barnblitz Outside"
		"CactusV.Inside" : "Cactus Valley Inside (Decoy)"
		"CactusV.RespawnA" : "Cactus Valley Respawn Room A (Decoy)"
		"CactusV.Outside" : "Cactus Valley Outside (Decoy)"
		"Chariots.Inside" : "Chariots Inside (Pipeline)"
		"Chariots.Outside" : "Chariots Outside (Pipeline)"
		"Deathpit.Inside" : "Deathpit Inside (Coaltown)"
		"Deathpit.RespawnA" : "Deathpit Respawn Room A (Coaltown)"
		"Deathpit.Outside" : "Deathpit Outside (Coaltown)"
		"DoubleCross.Inside" : "DoubleCross Inside"
		"DoubleCross.Outside" : "DoubleCross Outside"
		"Dustbowl.Indoors" : "Dustbowl Indoors"
		"Dustbowl.Outdoors" : "Dustbowl Outdoors"
		"Egypt.Indoor" : "Egypt Indoors"
		"Egypt.Outdoor" : "Egypt Outdoors"
		"Goldrush.DeepInside" : "Goldrush Deep Inside"
		"Goldrush.Outside" : "Goldrush Outside"
		"Goldrush.Inside" : "Goldrush Inside"
		"Gorge.Inside" : "Gorge Inside"
		"Gorge.Outside" : "Gorge Outside"
		"Granary.Outside" : "Granary Outside"
		"GravelPit.Outside" : "GravelPit Outside"
		"Halloween.Inside" : "Halloween Inside"
		"Halloween.Outside" : "Halloween Outside"
		"Halloween.Underworld" : "Halloween Underworld"
		"Halloween.hell" : "Halloween Hell"
		"Halloween_sf14.Outside" : "Halloween Outside"
		"Halloween_sf14.Inside" : "Halloween Inside"
		"harbor.inside_blue_spawn_01" : "Harbor Inside Blue Spawn (Foundry)"
		"harbor.inside_blue_hq" : "Harbor Inside Blue HQ (Foundry)"
		"harbor.indoor_blue_fuel" : "Harbor Indoor Blue Fuel (Foundry)"
		"harbor.outdoor_blue" : "Harbor Outdoor Blue (Foundry)"
		"harbor.inside_red_spawn_01" : "Harbor Inside Red Spawn (Foundry)"
		"harbor.inside_red_hq" : "Harbor Inside Red HQ(Foundry)"
		"harbor.indoor_red_fuel" : "Harbor Indoor Red Fuel (Foundry)"
		"harbor.outdoor_red" : "Harbor Outdoor Red (Foundry)"
		"harbor.outdoor_central" : "Harbor Outdoor Central (Foundry)"
		"Hellfire.Inside" : "Hellfire Inside"
		"Hellfire.OutsideCovered" : "Hellfire Outside Covered"		
		"Hellfire.Outside" : "Hellfire Outside"
		"HighTower.Inside" : "HighTower Inside"
		"HighTower.Outside" : "HighTower Outside"
		"Hydro.Outside" : "Hydro Outside"
		"Lair.VisitorsCenterSpawnBlue" : "Jungle Visitors Center Spawn Blue"		
		"Lair.VisitorsCenterSpawnBlueLightJungle" : "Jungle Visitors Center Spawn Blue Light"
		"Lair.JungleLight" : "Jungle Light"		
		"Lair.JungleUnderGround" : "Jungle Under Ground"	
		"Lair.JungleUndergroundLightJungle" : "Jungle Underground Light"		
		"Lair.Jungle" : "Jungle"	
		"Lair.JungleCap1InteriorTransition" : "Jungle Cap1 Interior Transition"		
		"Lair.Cap1Underground" : "Jungle Cap1 Underground"	
		"Lair.Cap1SpawnBlue" : "Jungle Cap1 Spawn Blue"	
		"Lair.Cap1" : "Jungle Cap1"	
		"Lair.Cap1Cap2Transition" : "Jungle Cap1 to Cap2 Transition"	
		"Lair.Cap2SpawnRed" : "Jungle Cap2 Red Spawn"	
		"Lair.Cap2SpawnBlue" : "Jungle Cap2 Blue Spawn"	
		"Lair.Cap2" : "Jungle Cap2"	
		"Lair.Cap3SpawnRed" : "Jungle Cap3 Red Spawn"	
		"Lair.Cap3" : "Jungle Cap3"	
		"Lair.Cap3Inside" : "Jungle Cap3 Inside"		
		"Lair.Cap3Duct" : "Jungle Cap3 Duct"		
		"Lair.Cap3Vista" : "Jungle Cap3 Vista"		
		"Lakeside.Cave" : "Lakeside Cave"
		"Lakeside.Inside" : "Lakeside Inside"
		"Lakeside.Lake" : "Lakeside Lake"
		"Lakeside.Outside" : "Lakeside Outside"
		"Lakeside.Temple" : "Lakeside Temple"
		"Lakeside.Wood" : "Lakeside Wood"
		"Lumberyard.Inside" : "Lumberyard Inside"
		"Lumberyard.Outside" : "Lumberyard Outside"
		"Mannworks.InsideCellars" : "Mannworks Inside Cellars"
		"Mannworks.InsideWood" : "Mannworks Inside Wood"
		"Mannworks.Outside" : "Mannworks Outside"
		"Mannworks.Respawn" : "Mannworks Respawn"
		"Medieval.Inside" : "Medieval Inside"
		"Medieval.Outside" : "Medieval Outside"
		"Moonbase.Outerspace" : "Moonbase Outerspace"
		"Moonbase.Underground" : "Moonbase Underground"
		"mountainlab.Bluspawn" : "Mountainlab Blue Spawn"
		"mountainlab.Cpoint" : "Mountainlab C Point"
		"mountainlab.Inside" : "Mountainlab Inside"
		"mountainlab.Outside1" : "Mountainlab Outside"
		"Nightfall.Cavern" : "Nightfall Cavern"
		"Nightfall.Indoors" : "Nightfall Indoors"
		"Nightfall.Outdoors" : "Nightfall Outdoors"
		"Nucleus.Inside" : "Nucleus Inside"
		"Nucleus.Outside" : "Nucleus Outside"
		"Powerhouse.Inside" : "Powerhouse Inside"
		"Powerhouse.InsideRed" : "Powerhouse Inside Red"		
		"Powerhouse.InsideBlue" : "Powerhouse Inside Blue"
		"Powerhouse.Transition" : "Powerhouse Transition"
		"Powerhouse.Outside" : "Powerhouse Outside"		
		"Ravine.Inside" : "Ravine Inside"
		"Ravine.Outside" : "Ravine Outside"
		"Rottenburg.Alcove" : "Rottenburg.Alcove"
		"Rottenburg.Clearing" : "Rottenburg Clearing"
		"Rottenburg.Spawn" : "Rottenburg Spawn"
		"Rottenburg.Town" : "Rottenburg Town"
		"Sawmill.Inside" : "Sawmill Inside"
		"Sawmill.InsideNoLights" : "Sawmill Inside No Lights"
		"Sawmill.InsideWaterfall" : "Sawmill Inside Waterfall"
		"Sawmill.Outside" : "Sawmill Outside"
		"soho_generic" : "Soho Generic (Kong King)"
		"soho_indoor" : "Soho Indoor (Kong King)"
		"soho_square" : "Soho Square (Kong King)"
		"underground_soho" : "Soho Underground (Kong King)"
		"stormfront.Underground" : "Stormfront Underground (Coldfront)"
		"stormfront.Outside" : "Stormfront Outside (Coldfront)"
		"ThunderMountain.Inside" : "ThunderMountain Inside"
		"ThunderMountain.Outside" : "ThunderMountain Outside"
		"Upward.Inside" : "Upward Inside"
		"Upward.Outside" : "Upward Outside"
		"Viaduct.Inside" : "Viaduct Inside"
		"Viaduct.Outside" : "Viaduct Outside"
		"warehouse.inside_boilers" : "Warehouse Inside Boilers (Mannhattan)"
		"warehouse.inside_mainhall" : "Warehouse Inside Main Hall (Mannhattan)"
		"warehouse.inside_spawn_foyer" : "Warehouse Inside Spawn Foyer (Mannhattan)"
		"warehouse.inside_spawn_int" : "Warehouse Inside Spawn Int (Mannhattan)"
		"warehouse.outside" : "Warehouse Outside"
		"Well.DeepInside" : "Well DeepInside"
		"Well.Inside" : "Well Inside"
		"Well.Outside" : "Well Outside"
	]
	
	radius(integer) : "Radius" : 128 : "Defines the entity's sphere of influence. Players must also be able to see the entity for it to trigger. -1 means infinite range."
	StartDisabled(boolean) : "Start Disabled?" : 0

	position0(target_destination) : "Sound Position 0" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position1(target_destination) : "Sound Position 1" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position2(target_destination) : "Sound Position 2" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position3(target_destination) : "Sound Position 3" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position4(target_destination) : "Sound Position 4" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position5(target_destination) : "Sound Position 5" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position6(target_destination) : "Sound Position 6" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position7(target_destination) : "Sound Position 7" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."

	input Enable(void) : "Enable the soundscape."
	input Disabled(void) : "Disable the soundscape."
	input ToggleEnabled(void) : "Toggle the soundscape enabled state."

	output OnPlay(void) : "Fired when this soundscape becomes the active one."
]

@PointClass base(BaseEntityPoint)  iconsprite("editor-ficool2/env_soundscape_proxy") sphere(radius) = env_soundscape_proxy : 
	"An entity that acts like a soundscape but gets all of its sound parameters from another env_soundscape entity."
[
	MainSoundscapeName(target_destination) : "Soundscape Entity" :  : "The soundscape to get all sound parameters from."
	radius(integer) : "Radius" : 128 : "Defines the entity's sphere of influence. Players must also be able to see the entity for it to trigger. -1 means infinite range."
]

// does not have radius keyvalue therefore we copy over instead and not inherit
@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_soundscape_triggerable") = env_soundscape_triggerable : 
	"An entity that works like env_soundscape except that it works in conjunction with trigger_soundscape to determine when a player hears it."
[
    // up to date as of 04/01/2019
	soundscape(choices) : "Soundscape" : "tf2.general_ambient" : "The name of the soundscape to use. Corresponds to an entry in the soundscapes*.txt file in the scripts directory." =
	[
		"tf2.general_ambient" : "General Ambience"
		"tf2.respawn_room" : "Respawn Room"
		"2fort.Underground" : "2Fort Underground"
		"2fort.Underground2" : "2Fort Underground2"
		"2fort.OutdoorPond" : "2Fort Outdoor Pond"
		"2fort.OutdoorFort" : "2Fort Outdoor Fort"
		"2fort.Indoor" : "2Fort Indoors"
		"Badlands.Inside" : "Badlands Inside"
		"Badlands.Outside" : "Badland Outside"
		"Badlands.OutsideInterior" : "Badlands Outside Interior"
		"barnblitz.inside" : "Barnblitz Inside"
		"barnblitz.outside" : "Barnblitz Outside"
		"CactusV.Inside" : "Cactus Valley Inside (Decoy)"
		"CactusV.RespawnA" : "Cactus Valley Respawn Room A (Decoy)"
		"CactusV.Outside" : "Cactus Valley Outside (Decoy)"
		"Chariots.Inside" : "Chariots Inside (Pipeline)"
		"Chariots.Outside" : "Chariots Outside (Pipeline)"
		"Deathpit.Inside" : "Deathpit Inside (Coaltown)"
		"Deathpit.RespawnA" : "Deathpit Respawn Room A (Coaltown)"
		"Deathpit.Outside" : "Deathpit Outside (Coaltown)"
		"DoubleCross.Inside" : "DoubleCross Inside"
		"DoubleCross.Outside" : "DoubleCross Outside"
		"Dustbowl.Indoors" : "Dustbowl Indoors"
		"Dustbowl.Outdoors" : "Dustbowl Outdoors"
		"Egypt.Indoor" : "Egypt Indoors"
		"Egypt.Outdoor" : "Egypt Outdoors"
		"Goldrush.DeepInside" : "Goldrush Deep Inside"
		"Goldrush.Outside" : "Goldrush Outside"
		"Goldrush.Inside" : "Goldrush Inside"
		"Gorge.Inside" : "Gorge Inside"
		"Gorge.Outside" : "Gorge Outside"
		"Granary.Outside" : "Granary Outside"
		"GravelPit.Outside" : "GravelPit Outside"
		"Halloween.Inside" : "Halloween Inside"
		"Halloween.Outside" : "Halloween Outside"
		"Halloween.Underworld" : "Halloween Underworld"
		"Halloween.hell" : "Halloween Hell"
		"Halloween_sf14.Outside" : "Halloween Outside"
		"Halloween_sf14.Inside" : "Halloween Inside"
		"harbor.inside_blue_spawn_01" : "Harbor Inside Blue Spawn (Foundry)"
		"harbor.inside_blue_hq" : "Harbor Inside Blue HQ (Foundry)"
		"harbor.indoor_blue_fuel" : "Harbor Indoor Blue Fuel (Foundry)"
		"harbor.outdoor_blue" : "Harbor Outdoor Blue (Foundry)"
		"harbor.inside_red_spawn_01" : "Harbor Inside Red Spawn (Foundry)"
		"harbor.inside_red_hq" : "Harbor Inside Red HQ(Foundry)"
		"harbor.indoor_red_fuel" : "Harbor Indoor Red Fuel (Foundry)"
		"harbor.outdoor_red" : "Harbor Outdoor Red (Foundry)"
		"harbor.outdoor_central" : "Harbor Outdoor Central (Foundry)"
		"Hellfire.Inside" : "Hellfire Inside"
		"Hellfire.OutsideCovered" : "Hellfire Outside Covered"		
		"Hellfire.Outside" : "Hellfire Outside"
		"HighTower.Inside" : "HighTower Inside"
		"HighTower.Outside" : "HighTower Outside"
		"Hydro.Outside" : "Hydro Outside"
		"Lair.VisitorsCenterSpawnBlue" : "Jungle Visitors Center Spawn Blue"		
		"Lair.VisitorsCenterSpawnBlueLightJungle" : "Jungle Visitors Center Spawn Blue Light"
		"Lair.JungleLight" : "Jungle Light"		
		"Lair.JungleUnderGround" : "Jungle Under Ground"	
		"Lair.JungleUndergroundLightJungle" : "Jungle Underground Light"		
		"Lair.Jungle" : "Jungle"	
		"Lair.JungleCap1InteriorTransition" : "Jungle Cap1 Interior Transition"		
		"Lair.Cap1Underground" : "Jungle Cap1 Underground"	
		"Lair.Cap1SpawnBlue" : "Jungle Cap1 Spawn Blue"	
		"Lair.Cap1" : "Jungle Cap1"	
		"Lair.Cap1Cap2Transition" : "Jungle Cap1 to Cap2 Transition"	
		"Lair.Cap2SpawnRed" : "Jungle Cap2 Red Spawn"	
		"Lair.Cap2SpawnBlue" : "Jungle Cap2 Blue Spawn"	
		"Lair.Cap2" : "Jungle Cap2"	
		"Lair.Cap3SpawnRed" : "Jungle Cap3 Red Spawn"	
		"Lair.Cap3" : "Jungle Cap3"	
		"Lair.Cap3Inside" : "Jungle Cap3 Inside"		
		"Lair.Cap3Duct" : "Jungle Cap3 Duct"		
		"Lair.Cap3Vista" : "Jungle Cap3 Vista"		
		"Lakeside.Cave" : "Lakeside Cave"
		"Lakeside.Inside" : "Lakeside Inside"
		"Lakeside.Lake" : "Lakeside Lake"
		"Lakeside.Outside" : "Lakeside Outside"
		"Lakeside.Temple" : "Lakeside Temple"
		"Lakeside.Wood" : "Lakeside Wood"
		"Lumberyard.Inside" : "Lumberyard Inside"
		"Lumberyard.Outside" : "Lumberyard Outside"
		"Mannworks.InsideCellars" : "Mannworks Inside Cellars"
		"Mannworks.InsideWood" : "Mannworks Inside Wood"
		"Mannworks.Outside" : "Mannworks Outside"
		"Mannworks.Respawn" : "Mannworks Respawn"
		"Medieval.Inside" : "Medieval Inside"
		"Medieval.Outside" : "Medieval Outside"
		"Moonbase.Outerspace" : "Moonbase Outerspace"
		"Moonbase.Underground" : "Moonbase Underground"
		"mountainlab.Bluspawn" : "Mountainlab Blue Spawn"
		"mountainlab.Cpoint" : "Mountainlab C Point"
		"mountainlab.Inside" : "Mountainlab Inside"
		"mountainlab.Outside1" : "Mountainlab Outside"
		"Nightfall.Cavern" : "Nightfall Cavern"
		"Nightfall.Indoors" : "Nightfall Indoors"
		"Nightfall.Outdoors" : "Nightfall Outdoors"
		"Nucleus.Inside" : "Nucleus Inside"
		"Nucleus.Outside" : "Nucleus Outside"
		"Powerhouse.Inside" : "Powerhouse Inside"
		"Powerhouse.InsideRed" : "Powerhouse Inside Red"		
		"Powerhouse.InsideBlue" : "Powerhouse Inside Blue"
		"Powerhouse.Transition" : "Powerhouse Transition"
		"Powerhouse.Outside" : "Powerhouse Outside"		
		"Ravine.Inside" : "Ravine Inside"
		"Ravine.Outside" : "Ravine Outside"
		"Rottenburg.Alcove" : "Rottenburg.Alcove"
		"Rottenburg.Clearing" : "Rottenburg Clearing"
		"Rottenburg.Spawn" : "Rottenburg Spawn"
		"Rottenburg.Town" : "Rottenburg Town"
		"Sawmill.Inside" : "Sawmill Inside"
		"Sawmill.InsideNoLights" : "Sawmill Inside No Lights"
		"Sawmill.InsideWaterfall" : "Sawmill Inside Waterfall"
		"Sawmill.Outside" : "Sawmill Outside"
		"soho_generic" : "Soho Generic (Kong King)"
		"soho_indoor" : "Soho Indoor (Kong King)"
		"soho_square" : "Soho Square (Kong King)"
		"underground_soho" : "Soho Underground (Kong King)"
		"stormfront.Underground" : "Stormfront Underground (Coldfront)"
		"stormfront.Outside" : "Stormfront Outside (Coldfront)"
		"ThunderMountain.Inside" : "ThunderMountain Inside"
		"ThunderMountain.Outside" : "ThunderMountain Outside"
		"Upward.Inside" : "Upward Inside"
		"Upward.Outside" : "Upward Outside"
		"Viaduct.Inside" : "Viaduct Inside"
		"Viaduct.Outside" : "Viaduct Outside"
		"warehouse.inside_boilers" : "Warehouse Inside Boilers (Mannhattan)"
		"warehouse.inside_mainhall" : "Warehouse Inside Main Hall (Mannhattan)"
		"warehouse.inside_spawn_foyer" : "Warehouse Inside Spawn Foyer (Mannhattan)"
		"warehouse.inside_spawn_int" : "Warehouse Inside Spawn Int (Mannhattan)"
		"warehouse.outside" : "Warehouse Outside"
		"Well.DeepInside" : "Well DeepInside"
		"Well.Inside" : "Well Inside"
		"Well.Outside" : "Well Outside"
	]
	
	StartDisabled(boolean) : "Start Disabled?" : 0

	position0(target_destination) : "Sound Position 0" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position1(target_destination) : "Sound Position 1" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position2(target_destination) : "Sound Position 2" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position3(target_destination) : "Sound Position 3" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position4(target_destination) : "Sound Position 4" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position5(target_destination) : "Sound Position 5" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position6(target_destination) : "Sound Position 6" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."
	position7(target_destination) : "Sound Position 7" :  : "A sound position that will be referenced inside the soundscape text file. Usually used to position a set of sounds within the world."

	input Enable(void) : "Enable the soundscape."
	input Disabled(void) : "Disable the soundscape."
	input ToggleEnabled(void) : "Toggle the soundscape enabled state."

	output OnPlay(void) : "Fired when this soundscape becomes the active one."
]

@PointClass base(BaseEntityPoint) iconsprite("editor/env_spark") = env_spark : 
	"An entity used to create sparks at its origin." 
[
	MaxDelay(string) : "Max Delay" : "0" : "The longest delay between sparks (in seconds)."
	Magnitude(choices) : "Magnitude" : 1 : "The size of the sparks." =
	[
		1 : "Small"
		2 : "Medium"
		5 : "Large"
		8 : "Huge"
	]

	TrailLength(choices) : "Spark Trail Length" : 1 : "Length of the spark trails." =
	[
		1 : "Short"
		2 : "Medium"
		3 : "Long"
	]

	spawnflags(flags) =
	[
		64: "Start ON" : 0
		128: "Glow" : 0
		256: "Silent" : 0
		512: "Directional" : 1
	]
	
	input StartSpark(void) : "Start the spark effect."
	input StopSpark(void) : "Stop the spark effect."
	input ToggleSpark(void) : "Toggle the on/off state of the spark effect."
	input SparkOnce(void) : "Spark once."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_splash") = env_splash : 
    "An entity that creates a splash effect at its origin, not necessarily in water."
[
	scale(float) : "Scale" : "8.0" : "Scale of the splash."
	
	spawnflags(flags) =
	[
		1: "Automatically find water surface (entity must be directly above water)" : 0
		2: "Diminish with depth (diminished completely in 10 feet of water)" : 1
	]

	input Splash(void) : "Create a splash effect."
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/env_sporeexplosion") = env_sporeexplosion : 
    "An entity that emits flying, yellow spores/particles like from Half Life 2's Bugbait."
[
	spawnrate(float) : "Spawn Rate (as percentage)" : "25" : "How dense the spore effect is. This percentage is not bound to 100; even values in the thousands are acceptable."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/env_sporetrail") = env_sporetrail : 
    "An entity that emits flying, yellow spores/particles like from Half Life 2's Bugbait, but in the form of a trail. Must be parented to take effect."
[
]

@PointClass base(BaseEntityPoint, Render) size(-2 -2 -2, 2 2 2) sprite() color(20 140 20) = env_sprite : 
	"An entity that controls the drawing of a sprite in the world."
[
	model(sprite) : "Sprite Name" : "sprites/glow01.spr" : "Material of the sprite to be drawn."
	frame(integer) : "Starting Frame" : 0 : "If the sprite is animated, the frame it should start animating on."
	framerate(float) : "Framerate" : "10.0" : "Rate at which the sprite should animate, if at all."
	scale(float) : "Scale" : "0.25" : "Scale multiplier of the sprite."
	GlowProxySize(float) : "Size of Glow Proxy Geometry." : "2.0" : "Size of the glow to be rendered for visibility testing. Must be larger than the distance from the sprite center to empty space.  So if this glow is inside geometry (like a light bulb), set this value to be bigger than the bulb's radius. Any time a sphere of this radius would be visible (poking through any nearby geometry), the glow will be rendered."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Color multiplier for players using HDR."
	
	spawnflags(flags) =
	[
		1: "Start On" : 1
		2: "Play Once - Used for animated sprites. Texture will animate once, then the sprite will turn off." : 0
	]
	
	input HideSprite(void) : "Hide the sprite. Won't be drawn until the 'ShowSprite' input is received."
	input ShowSprite(void) : "Show the sprite."
	input ToggleSprite(void) : "Toggle the sprite between hidden and shown."
	input ColorRedValue(float) : "Sets the red color channel's value (0 - 255)."
	input ColorGreenValue(float) : "Sets the green color channel's value (0 - 255)."
	input ColorBlueValue(float) : "Sets the blue color channel's value (0 - 255)."
	input SetScale(float) : "Set the sprite's scale."
]

@PointClass base(env_sprite) size(-2 -2 -2, 2 2 2) sprite() color(20 200 20) = env_sprite_oriented : 
    "A env_sprite that allows orientation. The sprite material needs to use $spriteorientation."
[
]

@PointClass base(BaseEntityPoint, Render) size(-2 -2 -2, 2 2 2) sprite() color(30 210 65) = env_spritetrail : 
	"Emits a sprite, intended to create a trail effect when moving. Must be parented to something."
[
	lifetime(float) : "Lifetime" : "0.5" : "How long the beam is shown."
	startwidth(float) : "Start Width" : "8.0" : "The width of the beam to the beginning."
	endwidth(float) : "End Width" : "1.0" : "The width of the beam when it has full expanded."
	spritename(sprite) : "Sprite Name" : "sprites/bluelaser1.vmt" : "The material to draw."
	animate(boolean) : "Animated?" : "0" : "Tells the sprite to animate if it can."

	frame(integer) : "Starting Frame" : 0 : "If the sprite is animated, the frame it should start animating on."
	framerate(float) : "Framerate" : "10.0" : "Rate at which the sprite should animate, if at all."
	scale(float) : "Scale" : "0.25" : "Scale multiplier of the sprite."
	GlowProxySize(float) : "Size of Glow Proxy Geometry." : "2.0" : "Size of the glow to be rendered for visibility testing. Must be larger than the distance from the sprite center to empty space.  So if this glow is inside geometry (like a light bulb), set this value to be bigger than the bulb's radius. Any time a sphere of this radius would be visible (poking through any nearby geometry), the glow will be rendered."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Color multiplier for players using HDR."
	
	input HideSprite(void) : "Hide the sprite. Won't be drawn until the 'ShowSprite' input is received."
	input ShowSprite(void) : "Show the sprite."
	input ToggleSprite(void) : "Toggle the sprite between hidden and shown."
	input ColorRedValue(float) : "Sets the red color channel's value (0 - 255)."
	input ColorGreenValue(float) : "Sets the green color channel's value (0 - 255)."
	input ColorBlueValue(float) : "Sets the blue color channel's value (0 - 255)."
	input SetScale(float) : "Set the sprite's scale."	
]

@PointClass base(BaseEntityPoint, Render) studioprop("models/editor/spot_cone.mdl") = env_steam : 
	"An entity used to create a jet of steam, or heat wave distortion."
[
	InitialState(choices) : "Initial State" : 0 = 
	[
		0 : "Off"
		1 : "On"
	]

	type(choices) : "Particle Type" : 0 =
	[
		0 : "Normal"
		1 : "Heat Wave"
	]

	SpreadSpeed(integer) : "Spread speed" : 15 : "The amount of random spread in the particle's velocity after they spawn."
	Speed(integer) : "Speed" : 120 : "The default speed at which the particles move after they spawn."
	StartSize(integer) : "Particle start size" : 10 : "The initial size of the particles after they spawn."
	EndSize(integer) : "Particle end size" : 25 : "The size of the particles at the point at which they are removed."
	Rate(integer) : "Emission rate" : 26 : "The rate of particle emission. i.e. particles per second."
	rendercolor(color255) : "Color (R G B)" : "255 255 255" : "Steam color, only used if Emissive flag is set."
	JetLength(integer) : "Length of steam jet" : 80 : "The length of the jet determines the lifetime of each particle."
	renderamt(integer) : "Translucency" : 255 : "Opacity of the steam."
	rollspeed(float) : "Roll speed" : 8 : "The speed at which particles spin."
	
	spawnflags(flags) =
	[
		1 : "Emissive - Uses the value specified in Color. If not checked, color is automatically determined by environmental lighting." : 0
	]
	input TurnOn(void) : "Turns the steam jet on."
	input TurnOff(void) : "Turns the steam jet off."
	input Toggle(void) : "Toggles the steam jet between on and off."
	input JetLength(integer) : "Sets the length of steam jet."
	input Rate(integer) : "Sets the particle emission rate in particles per second."
	input Speed(integer) : "Sets the default speed of the particles in units per second."
	input SpreadSpeed(integer) : "Sets the spread speed in units per second."
	input Color(color255) : "Changes the steam particle color."
	input Alpha(integer) : "Changes the steam particle translucency."
]

@PointClass base(env_steam) studioprop("models/editor/spot_cone.mdl") = env_steamjet : 
	"Legacy support: Same as env_steam, although faces left instead of forward."
[
]


@PointClass base(BaseEntity, Angles) iconsprite("editor-ficool2/env_sun") = env_sun : 
	"An entity used to control and draw a sun effect in the sky."
[
	target(target_destination) : "Viewer entity" : : "Name of an entity used to determine where the sun is in the skybox. The resulting sun sprite will be positioned based on a line starting from the Viewer entity towards the env_sun."
	
	use_angles(boolean) : "Use Angles?" : 1 : "If set to No, orient the sun by targetting an entity. If set to Yes, orient the sun with defined angles." 

	pitch(float) : "Pitch" : 0 : "This value sets the pitch position of the sun. It overrides the Pitch in Pitch Yaw Roll, even if left at 0, so it needs to be specified. This Pitch is reverse of the normal, so 90 is straight up, while -90 is straight down."
	angle(float) : "Yaw" : 0 : "Override for Yaw in Pitch Yaw Roll, similar to Pitch."

	material(sprite) : "Material Name" : "sprites/light_glow02_add_noz" : "Material of the inner glow."
	rendercolor(color255) : "Sun Color (R G B)" : "100 80 80" : "Color of the sun. The effect is additive with the sky: a pure yellow sun with a bright blue sky will appear white in-game; change the color to account for this."
	size(integer) : "Size" : 16 : "Size of the sun."
	overlaymaterial(sprite) : "Overlay Material Name" : "sprites/light_glow02_add_noz" : "Material of the overlay glow."
	overlaycolor(color255) : "Overlay Color (R G B)" : "0 0 0" : "Color of the sun overlay."
	overlaysize(integer) : "Overlay Size" : -1 : "A value of -1 means the overlay will act the old way."
	
	HDRColorScale(float) : "HDR color scale." : "1.0" : "Color multiplier when in HDR mode."

	input TurnOn(void) : "Enable sun rendering."
	input TurnOff(void) : "Disable sun rendering."
	input SetColor(color255) : "Change the sun's color."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_texturetoggle") = env_texturetoggle : 
     "An entity that allows you to change the animated texture frame on an entity that uses animated textures. Alternatively, you can change the 'texframeindex' keyvalue on an entity with AddOutput, although it will be slower to update."
[
	target(target_destination) : "Target" : : "Name of the entity. All ToggleTexture materials on all entities (including sprites) matching the targetname will be affected." 

	input IncrementTextureIndex(void) : "Increments target's current texture frame by one."
	input SetTextureIndex(integer) : "Sets target's texture frame to the specified index."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_tonemap_controller") = env_tonemap_controller : 
	"An entity that controls the HDR tonemapping for the player. Think of it as a method of controlling the exposure of the player's eyes."
[
	input SetTonemapScale(float) : "Set the player's tonemap scale - the openness of his pupils. Parameter should be a value between 0 and 2, where 0 is the eyes fully closed, 1 is the unchanged autoexposure (default), and 2 is the eye fully wide open.  Fades back to 1 via the current TonemapRate."
	input BlendTonemapScale(string) : "SetTonemapScale performed over a length of time.  Parameter should be a value between 0 and 2 followed by a length of time in seconds.  This appears jumpy, as if the TonemapRate fights the transition."
	input SetTonemapRate(string) : "Set the TonemapRate, the rate at which the player's eyes adjust to light.  Higher values denote faster adjustments."
	input SetAutoExposureMin(string) : "Set AutoExposureMin, the minimum amount that the player's pupils are allowed to be open when automatically adjusting.  Overrides AutoExposureMax if Min>Max."
	input SetAutoExposureMax(string) : "Set AutoExposureMax, the maximum amount that the player's pupils are allowed to be open when automatically adjusting."
	input SetBloomScale(string) : "Set BloomScale, a scalar for the size of light bloom effects."
	input SetBloomScaleRange(vector) : "Sets a range for the bloom scale. First number is the maximum, second number is the minimum. "
	input UseDefaultAutoExposure(void) : "Use the default AutoExposureMin and AutoExposureMax values."
	input UseDefaultBloomScale(void) : "Use the default BloomScale."
]

@PointClass base(BaseEntityPoint) line(255 255 255, targetname, target) iconsprite("editor-ficool2/env_tracer") = env_tracer : 
	"An entity that fires a thin tracer between itself and a target, with a specified delay. The tracer does not follow or update the target. The tracer always fires at its original position, even if the target is killed."
[
	target(target_destination) : "Target" : : "The target to fire the tracer at. Must be 256 or more units away from the env_tracer."
	delay(float) : "Delay" : 1 : "How long to wait before firing the tracer again, in seconds."
]

@PointClass base(BaseEntityPoint) sphere(radius) iconsprite("editor-ficool2/env_viewpunch") = env_viewpunch :
	"An entity that applies a view punch on players according to the origin, radius, and angle." 
[
	punchangle(angle) : "Punch angles" : "0 0 90" : "The punch angles to apply."
	radius(float) : "Effect Radius" : "512" : "The radius around this entity in which to affect players."

	spawnflags(flags) =
	[
		1: "Punch all players (ignore radius)" : 0
		2: "Punch players in the air" : 1
	]

	input ViewPunch(void) : "Performs the view punch."
]

@PointClass base(BaseEntity, Angles) iconsprite("editor-ficool2/env_wind") = env_wind : 
	"An entity to control wind in the map. Can be used to control $treesway on models."
[
	gustsound(sound) : "Gust Sound Filename" :  : "Sound to be played to simulate the gusting wind."
	minwind(integer) : "Min normal speed" : 20 : "Minimum speed of the wind while idling."
	maxwind(integer) : "Max normal speed" : 50 : "Maximum speed of the wind while idling."

	mingust(integer) : "Min gust speed" : 100 : "Minimum speed of wind gusts."
	maxgust(integer) : "Max gust speed" : 250 : "Maximum speed of wind gusts."

	mingustdelay(integer) : "Min gust delay" : 10 : "Minimum time delay between random gusts."
	maxgustdelay(integer) : "Max gust delay" : 20 : "Maximum time delay between random gusts."

	gustduration(integer) : "Gust Duration" : 5 : "How long will the wind gust for."
	gustdirchange(integer) : "Max gust dir change (degrees)" : 20 : "Maximum amount that the wind's direction changes due to a gust."
	
	output OnGustStart(void) : "Fired when a wind gust begins."
	output OnGustEnd(void) : "Fired when a wind gust ends."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_zoom") = env_zoom : 
	"An entity that can be used to control the player's FOV. Useful for scenes where the player's view is being controlled, or player-usable binoculars/telescopes, etc. Does not function in Team Fortress 2."
[
	Rate(float) : "Seconds to reach target" : "1.0" : "Amount of time it should take to reach the specified FOV."
	FOV(integer) : "Target FOV" : 75 : "FOV that this entity should set the player's FOV to when active."

	spawnflags(flags) =
	[
		1: "Allow Suit Zoom" : 0
	]

	input Zoom(void) : "Start controlling the player's FOV."
	input UnZoom(void) : "Stop controlling the player's FOV."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_activator_class") = filter_activator_class :
	"A filter that filters by the class name of the activator. Entities can have their classnames changed using AddOutput. "+
	"Warning: changing classnames can lead to strange behaviour or crashes upon round restart!"
[
	filterclass(string) : "Filter Classname" : : "The class name to filter by. If the filter mode is Allow, only entities whose "+
		"class name matches the given string will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose class name matches the given string will pass the filter."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_activator_name") = filter_activator_context :
	"A filter that filters by a context on the activator."
[
	ResponseContext(string) : "Filter Context" : : "The context to filter by. If the filter mode is Allow, only entities that "+
		"have a context matching the given string, of any value, will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose context matches the string will pass the filter."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_activator_mass_greater") = filter_activator_mass_greater :
	"A filter that filters by the mass of the activator."
[
	filtermass(float) : "Filter Mass" : : "The mass to filter by. If the filter mode is Allow, only entities whose "+
		"mass is greater than the give float will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose mass is greater than the given float will pass the filter."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_activator_name.vmt") = filter_activator_model :
	"A filter that filters by the model of the activator."
[
	model(studio) : "Filter Model" : : "The model to filter by. If the filter mode is Allow, only entities whose "+
		"model matches the given string will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose model matches the string will pass the filter."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_activator_name") = filter_activator_name :
	"A filter that filters by the name of the activator."
[
	filtername(target_destination) : "Filter Name" : : "The name to filter by. If the filter mode is Allow, only entities whose "+
		"name matches the given string will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose name matches the string will pass the filter."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_activator_team") = filter_activator_team :
	"A filter that filters by the team of the activator."
[
	filterteam(choices) : "Filter Team Number" : 2 : "The team number to filter by.  If the filter mode is Allow, only entities whose "+
		"team number matches the given team will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose team number matches the given team will pass the filter." =
	[
		0 : "0 - Unassigned"
		1 : "1 - Spectators"
		2 : "2 - RED"
		3 : "3 - BLU"
		4 : "4 - Mercenary"	
	]
]

@FilterClass base(BaseEntity, BaseFilter, TeamNum) iconsprite("editor-ficool2/filter_activator_tfteam") = filter_activator_tfteam :
	"A filter that filters by the team of the activator.  The team number to filter by. " +
	"If the filter mode is Allow, only entities whose team number matches the given team will " +
	"pass the filter. If the filter mode is Disallow, all entities EXCEPT those whose team number " +
	"matches the given team will pass the filter." 
[
	controlpoint(target_destination) : "Associated Control Point" :  : "The team_control_point associated with this filter. The filter does NOT need an associated control point to function properly, but ownership of the control point will control the team number the filter uses (setup during each round start)."

	input RoundSpawn(void) : "Forces this entity to spawn. Fired automatically at the start of a round."
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_base") = filter_base:
	"This filter defines the common functionality shared by all filter types. This entity technically can't filter anything on its own. Every entity is accepted (or rejected, if Negated is set)."
[
]

@FilterClass base(BaseEntity, BaseFilter, DamageType) iconsprite("editor-ficool2/filter_damage_type")  = filter_damage_type :
	"A damage filter that filters by the type of damage inflicted. This can only be used as a damage filter, not as an activator filter. Does not function in Team Fortress 2."
[
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_enemy") sphere(filter_radius) sphere(filter_outer_radius) = filter_enemy :
	"A filter that filters an entity by a set of criteria."
[
	filtername(string) : "Name/Classname" : : "The classname or entity name to filter by. If the filter mode is Allow, only entities whose "+
		"class name matches the given string will pass the filter. If the filter mode is Disallow, "+
		"all entities EXCEPT those whose class name matches the given string will pass the filter."
		
	filter_radius(float) : "Radius" : 0 : "Radius by which to test the proximity of the enemy.  If the filter mode is Allow, only entities whose "+
		"distance is equal to or closer than the radius will pass the filter. If the filter mode is Disallow, "+
		"all entities outside the radius will pass the filter."

	filter_outer_radius(float) : "Outer Radius" : 0 : "Enemies outside this radius are considered invalid if Allow is set and valid if Disallow is set."
	
	filter_max_per_enemy(integer) : "Max Squadmates Per Enemy" : 0 : "Maximum number of squadmates allowed to target any given entity."
	
	spawnflags(Flags) =
	[
		1 : "Do not lose target if already aquired but filter failed" : 0
	]
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_multi") = filter_multi :
	"A filter that tests the activator against multiple filters. This allows you to build more complex filters, such as"+
	"'Allow anyone on Team 1 who is also class engineer', or 'Allow everyone except classes npc_zombie and npc_headcrab'."
[
	filtertype(choices) : "Logic Type" : 0 =
	[
		0 : "AND (all filters must pass)"
		1 : "OR (any filter must pass)"
	]

	Negated(boolean) : "Negate Outcome?" : 0 : "Whether to negate the result of the subfilters, after combining them using the Logic Type chosen.\n"+
		"Negating the outcome using the AND logic type means that any subfilter must fail for this filter to pass.\n"+
		"Negating the outcome using the OR logic type means that all subfilters must fail for this filter to pass."

	Filter01(filterclass) : "Filter 1" : : "Activator filter to test."
	Filter02(filterclass) : "Filter 2" : : "Activator filter to test."
	Filter03(filterclass) : "Filter 3" : : "Activator filter to test."
	Filter04(filterclass) : "Filter 4" : : "Activator filter to test."
	Filter05(filterclass) : "Filter 5" : : "Activator filter to test."
	Filter06(filterclass) : "Filter 6" : : "Activator filter to test."
	Filter07(filterclass) : "Filter 7" : : "Activator filter to test."
	Filter08(filterclass) : "Filter 8" : : "Activator filter to test."
	Filter09(filterclass) : "Filter 9" : : "Activator filter to test."
	Filter10(filterclass) : "Filter 10" : : "Activator filter to test."
	Filter11(filterclass) : "Filter 11" : : "Activator filter to test."
	Filter12(filterclass) : "Filter 12" : : "Activator filter to test."
	Filter13(filterclass) : "Filter 13" : : "Activator filter to test."
	Filter14(filterclass) : "Filter 14" : : "Activator filter to test."
	Filter15(filterclass) : "Filter 15" : : "Activator filter to test."
	Filter16(filterclass) : "Filter 16" : : "Activator filter to test."	
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_tf_class") = filter_tf_class :
	"A filter that filters by the class of the activator.  The team number to filter by. " +
	"If the filter mode is Allow, only entities whose class matches the given class will " +
	"pass the filter. If the filter mode is Disallow, all entities EXCEPT those whose class " +
	"matches the given class will pass the filter." 
[
	tfclass(choices) : "Class" : 0 : "Class" =
	[
		1 : "Scout"
		2 : "Sniper"
		3 : "Soldier"
		4 : "Demoman"
		5 : "Medic"
		6 : "Heavy"
		7 : "Pyro"
		8 : "Spy"
		9 : "Engineer"
		10 : "Mercenary"
		11 : "Civilian"
	]
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_tf_damaged_by_weapon_in_slot") = filter_tf_damaged_by_weapon_in_slot :
	"A filter that filters damage by a weapon in a certain slot."
[
	weaponSlot(choices) : "Weapon Slot" : 0 : "Damaged by weapon in slot." =
	[
		0 : "Primary"
		1 : "Secondary"
		2 : "Melee"
		3 : "Grenade"
		4 : "Building"
		5 : "PDA"
		6 : "Item 1"
		7 : "Item 2"
	]
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_tf_class") = filter_tf_money :
	"A filter that filters by the amount of money you have " +
[
	moneyamount(integer) : "Money Value" : 0 : "What value should be checked."
	checktype(choices) : "Alow if Money is" : 0 : "Check if activator money is bigger, less or equal to the set value" =
	[
		0 : ">"
		1 : "<"
		2 : "="
	]
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_tf_class") = filter_tf_owns_weapon :
	"A filter that filters by the amount of money you have " +
[
	weaponname(string) : "Weapon Name" : : "What weapon it should search for."
]

@FilterClass base(BaseEntity, BaseFilter) iconsprite("editor-ficool2/filter_tf_class") = filter_tf_active_weapon :
	"A filter that filters by the amount of money you have " +
[
	weaponname(string) : "Weapon Name" : : "What weapon it should search for."
]

// Special exception: the areaportal becomes a point entity at runtime, making its brush variant Hammer internal only
@SolidClass base(BaseEntity) color(0 255 255) = func_areaportal :
	"A portal brush used to manage visibility in maps. Portals define areas, which are spaces " +
	"that are connected in the map. Both sides of a portal cannot touch the same area, for example, a " +
	"doughnut shaped map would require at least two portals to divide the map into two areas. A linear map " +
	"could be divided into two areas with a single area portal. The areaportal becomes a point entity at runtime."
[
	target(target_destination) : "(Optional) Name of Linked Door" : : "A prop_door_rotating or func_door whose open/closed state controls the on/off state of the portal."
	StartOpen(choices) : "Initial State" : 1 =
	[
		0 : "Closed"
		1 : "Open"
	]
	
	input Open(void) : "Open the portal. When the portal is open is can be seen through."
	input Close(void) : "Close the portal. When the portal is closed it cannot be seen through."
	input Toggle(void) : "Toggle the open/closed state of the portal."
]

// Special exception: the areaportalwindow becomes a point entity at runtime, making its brush variant Hammer internal only
@SolidClass base(BaseEntity) color(0 128 255) = func_areaportalwindow : 
	"An entity that can be used to optimize the visibility in a map. If you seal off an area with them, when the viewer moves the specified distance away from them, they will go opaque and the parts inside the area will not be drawn. The 'target' brush model should enclose the func_areaportal window so no parts of it are culled by the window. If you use the optional foreground brush model, then it should enclose the 'target' brush model."
[
	target(target_destination)  : "Rendered Window" : : "The brush entity that fills the gap left by the portal when closed."
	FadeStartDist(integer) : "Fade Start Distance" : 128 : "Distance that the fade into the Rendered Window brush entity begins. The further back the player views, the more visible the brush entity will be."
	FadeDist(integer) : "Fade End Distance"   : 512 : "Distance at which the Rendered Window is fully visible, and the portal closes."
	TranslucencyLimit(string) : "Translucency limit"  : "0.2" : "Prevents the Rendered Window brush from ever going completely transparent. Useful if your rendered window uses an opaque glass material."
	BackgroundBModel(string) : "Background Brush"  :  : "Optional brush entity that is drawn after the fading brush model. This model should have alpha in its textures so you can see through it."
	
	input SetFadeStartDistance(integer) : "Sets fade start distance."
	input SetFadeEndDistance(integer) : "Sets fade end distance."
]

// All keyvalues are defined manually for this instead of taking from Breakable base as the keyvalue/input/output inconsistency is horrendous
@SolidClass base(BreakableBrush) sphere(exploderadius) = func_breakable : 
	"A brush entity that can be broken from damage, or an input." 
[
]

// Same as func_breakable
@SolidClass quadbounds() base(BreakableBrush) sphere(exploderadius) = func_breakable_surf : 
	"A breakable surface, for partially breakable glass / tile / etc.  All faces but the desired visible one must be marked as NODRAW and that" +
	"face must be 4 sided.  The material applied to the visible face must be set up to be breakable." 
[
	health(integer) : "Health" : 5 : "The amount of damage the surface takes before breaking."
	fragility(integer) : "Fragility" : 100 : "If the 'Surface Type' is set to Glass, this value sets how fragile the glass pieces are after the surface has been broken."
	surfacetype(choices) : "Surface Type" : 0 = 
	[
		0 : "Glass"
		1 : "Tile"
	]
	upperleft(vector) : "Upper-left corner" : : "Read-only keyvalue for quad bound testing."
	upperright(vector) : "Upper-right corner" : : "Read-only keyvalue for quad bound testing."
	lowerleft(vector) : "Lower-left corner" : : "Read-only keyvalue for quad bound testing."
	lowerright(vector) : "Lower-right corner" : : "Read-only keyvalue for quad bound testing."
	error(choices) : "Error Type" : 0 : "Set automatically by Hammer to indicate an invalid surface." = 
	[
		0 : "No Error"
		1 : "Multiple Textured Faces"
		2 : "Non-Square Face"
	]
	
	spawnflags(Flags) = 
	[
		1 : "Physics damage decals" : 0
		2 : "Take damage from held objects" : 0
	]	
	
	input Shatter(vector) : "Shatter the window. Input a vector. First two coordinates are the X,Y center of the shattering (as values from from 0-1). The third coordinate is the radius of the shatter, in units."
]

@SolidClass base(BaseAnimatingBrush, EnableDisable) = func_brush : 
	"An brush built entity with various features." 
[
	Solidity(choices) : "Solidity" : 0 : "Used to control the solidity/collision of these brushes. Disabling/enabling the entity will also change solidity/collision." =
	[
		0 : "Toggle"
		1 : "Never Solid"
		2 : "Always Solid"
	]
	excludednpc(string) : "NPC class excluded from collisions" :  : "If an NPC classname is specified here, NPCs of that type won't collide with these brushes. In Episodic, you may also specify an individual entity's name."
	invert_exclusion(boolean) : "Invert NPC class exclusion" : 0 : "If set, then the excluded NPC class will consider this brush solid, and all other NPC classes will consider it non-solid."

	solidbsp(boolean) : "Solid BSP?" : 0 : "Set this if this brush is in hierarchy with a moving object of some kind, and the player can stand on this brush."
	
	spawnflags(flags) =
	[
		2: "Ignore player +USE" : 1
	]
	
	input SetExcluded( string ) : "Change the NPC class excluded from collisions."
	input SetInvert( integer ) : "Set the state of inversion for NPC class exclusion (0 or 1)."
	input Toggle(void) : "Toggle the entity."
]

@SolidClass base(func_brush) = func_bulletshield :
	"A shield that stops only bullets."
[

]

@SolidClass base(BaseAnimatingBrush) = func_button : 
	"A brush entity that's designed to be used for a player-useable button. When used by the player, it moves to a pressed position. Do not lock while pressed; it will not return when unlocked."
[
	movedir(angle) : "Move Direction (Pitch Yaw Roll)" : "0 0 0" : "Specifies the direction of motion to move when the button is used."
	speed(integer) : "Speed" : 5 : "The speed that the button moves, in units per second."
	health(integer) : "Health" : 0 : "Legacy method of specifying whether or not the button can be shot to activate it. Use the 'Damage Activates' spawnflag instead."
	lip(integer) : "Lip" : 0 : "The amount, in units, of the button to leave sticking out of the wall it recedes into when pressed. Negative values make the button recede even further into the wall."

	sounds(choices) : "Sounds" : "0" : "Button sounds. Not all sounds will work in all games!" = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]	

	wait(integer) : "Delay Before Reset (-1 stay)" : 3 : "Amount of time, in seconds, after the button has been pressed before it returns to the starting position. Once it has returned, it can be used again. If the value is set to -1, the button never returns."

	locked_sound(choices) : "Locked Sound" : 0 : "Sound played when the player tries to use the button, and fails because it's locked." = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]
	unlocked_sound(choices) : "Unlocked Sound" : 0 : "Sound played when the button is unlocked." = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]
	
	spawnflags(flags) =
	[
		1: "Don't move" : 0
		32: "Toggle" : 0
		256: "Touch Activates": 0
		512: "Damage Activates": 1
		1024: "Use Activates" : 1
		2048: "Starts locked" : 0
		4096: "Sparks" : 0
	]
	
	input Lock(void) : "Lock the button, preventing it from functioning."
	input Unlock(void) : "Unlock the button, allowing it to function."
	input Press(void) : "Activate the button as if it was pressed."
	input PressIn(void) : "Activate the button as if it was pressed, sending it to the bottom position."
	input PressOut(void) : "Unpress the button, sending it to the top position."
	
	output OnDamaged(void) : "Fired when the button is damaged."
	output OnPressed(void) : "Fired when the button is pressed."
	output OnUseLocked(void) : "Fired when the button is used while locked."
	output OnIn(void) : "Fired when the button reaches the in/pressed position."
	output OnOut(void) : "Fired when the button reaches the out/released position."
]

@SolidClass base(Trigger, TeamNum) = func_capturezone :
	"Team Fortress 2 flag capture zone (set Team to 'any' for Territory Control maps)."
[
	capturepoint(integer) : "Capture Point" : 1 : "Used for Attack/Defend and Territory Control maps ONLY. This is ignored for CTF maps. Set this value to the Capture Point number for this entity."
	
	output OnCapture(void) : "Sent when a flag is captured in this zone."
]

@SolidClass base(Trigger, TeamNum) = func_changeclass :
	"Obsoleted by func_respawnroom. Allows players to change class without suiciding in its volume."
[
]

@SolidClass base(BaseAnimatingBrush) = func_clip_vphysics : 
	"A brush entity which is considered solid to VPhysics objects (such as a prop_physics). QPhysics objects (such as players) can pass freely."
[
	filtername(filterclass) : "Filter Name" : : "Filter to use to see if activator collides with me. See filter_activator_name for more explanation. Allow means 'Allow to Block' for this entity."
	
	input Enable(void) : "Enable this entity."
	input Disable(void) : "Disable this entity."
]

@SolidClass base(BaseAnimatingBrush) = func_conveyor : 
	"A brush entity that functions as a conveyor belt, with a moving surface. The surface material should have a ConveyorScroll Material Proxy, to synchronize the material movement and push effect."
[
	movedir(angle) : "Move Direction (Pitch Yaw Roll)" : "0 0 0" : "The direction conveyor moves."
	spawnflags(flags) =
	[
		1 : "No Push" : 0
		2 : "Not Solid" : 0
	]
	speed(string) : "Conveyor Speed" : "100"

	input ToggleDirection(void) : "Change direction of conveyor."
	input SetSpeed(integer) : "Sets Conveyor Speed."
]

@SolidClass base(Trigger, TeamNum) = func_croc :
    "Similar to trigger_hurt, but instead the player is instantly gibbed by a sudden crocodile upon touching. Spawns an entity_croc when used."
[
	output OnEat(void) : "Fired when the entity consumes a player."
	output OnEatRed(void) : "Fired when the entity consumes a player on the RED team."
	output OnEatBlue(void) : "Fired when the entity consumes a player on the BLU team."
	output OnEatMercenary(void) : "Fired when the entity consumes a player on the Mercenary team."
]

@SolidClass color(0 180 0) = func_detail : 
	"An entity that turns its brushes into detail brushes. Detail brushes do NOT contribute to visibility in the PVS. World geometry "+
	"is not clipped to detail brushes, so if you have a small detail clump attached to a wall, the wall won't be cut up by the detail brush."+
	"func_detail is great for high-frequency brush geometry that's visual detail only. It is also ideal for reducing map VIS time."
[
]

@SolidClass = func_detail_blocker : 
	"A brush entity that prevents detail sprites from being placed inside its volume."
[
]

@SolidClass base(Door) = func_door : 
	"A brush entity for use as a player-useable door."
[
	movedir(angle) : "Move Direction (Pitch Yaw Roll)" : "0 0 0" : "The direction the door will move, when it opens."
]

@SolidClass base(Door) = func_door_rotating : 
	"A brush entity for use as a rotating player-useable door."+
[
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."
	distance(integer) : "Distance" : 90 : "The amount, in degrees, that the button should rotate when it's pressed."
	solidbsp(choices) : "Solid Type" : 1 : "How to calculate collisions. BSP is more rudimentarty but allows more stable collision with players." =
	[
		0 : "VPhysics"	
		1 : "BSP"
	]

	spawnflags(flags) =
	[
        1 : "Starts Open - Obsolete. Some outputs don't work" : 0
		2 : "Reverse Direction -  This door opens in the opposite direction" : 0
		4 : "Non-Solid to Player -  Player cannot colide, but everything else can. Not compatible with Ignore Debris" : 0
		8: "Passable -  Door is solid to nothing at all" : 0
		16: "One-Way --  This door only opens in one direction" : 0
	    32: "Toggleable - The door is given an input to change this door between open and shut" : 0
		64: "X Axis - This door rotates on the X axis" : 0
		128: "Y Axis - This door rotates on the Y axis" : 0
		256: "Use Opens - The door will open if it receives a +USE input from a player. Useless in TF2 as +USE is hidden in obscurity" : 0
		512: "NPCs can't Open - NPCs can't open this door" : 0
		1024: "Touch Opens - When a player or NPC touches the door, it will count as an attempt to open it" : 0
		2048: "Starts Locked - This door spawns locked and cannot be opened by the player or NPCs (but buttons can still trigger it)" : 0
		4096:	"Door Silent -  This door makes no noise" : 0
		65536: "New +USE rules - Allow +USE only when when the door is closed/closing or is open/opening and can be manually closed" : 0
	]
]

// have to merge BaseEntityBrush into this as the origin keyvalue breaks stuff, unfortunately
@SolidClass = func_dustcloud : 
	"A brush entity that spawns a translucent dust cloud within its volume. Affected by env_wind."+
	"This entity is hardcoded to use the material particle/sparkles.vmt, which is extremely low-resolution. You may consider overriding this .vmt for improved appearance."
[
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."

	effects(choices) : "Effect flags" : 0 : "For configuring visual effects. If you want to combine effects, turn SmartEdit off and add the effect numbers together, i.e. 64 + 8 = 72." =
	[
		0 : "None"
		1 : "Bonemerge, very expensive!!"
		2 : "Bright, dynamic light at entity origin"
		4 : "Dim, dynamic light at entity origin"
		8 : "No movement interpolation"
		16 : "Don't cast shadows"
		32 : "Don't draw entity (entity is fully ignored by clients, NOT server)"
		64 : "Don't receive dynamic shadows"
		128 : "Bonemerge only in PVS, better performance but prone to disappearing. Use with Bonemerge."
		256 : "Blinking glow"
		512 : "Flag parent as always animating and realign each frame"
		// Portal 2 and later only
//      1024 : "Mark for fast reflections"
//      2048 : "No shadow depth, for use with env_cascade_light"
//      4096 : "No projected textures"
	]
	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]

	linedivider2(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""
	
	StartDisabled(boolean) : "Start Disabled?" : 0 : "Don't create particles when spawned."

	Color(color255) : "Particle Color (R G B)" : "255 255 255" : "Color of the particles."
	Alpha(integer) : "Particle Translucency (0 - 255)" : 30 : "Transluceny of the particles."
	SpawnRate(integer) : "Particle Per Second" : 40 : "Number of particles to spawn, per second."
	SpeedMax(string) : "Maximum Particle Speed" : 13 : "Maximum speed that the particles can move after spawning."
	LifetimeMin(string) : "Minimum Particle Lifetime" : 3 : "Minimum number of seconds until each particle dies. Particles live for a random duration between this and 'Maximum Particle Lifetime'."
	LifetimeMax(string) : "Maximum Particle Lifetime" : 5 : "Maximum number of seconds until each particle dies. Particles live for a random duration between 'Minimum Particle Lifetime' and this."
	DistMax(integer) : "Maximum Visible Distance" : 1024 : "Maximum distance at which particles are visible. They fade to translucent at this distance."
	SizeMin(string) : "Minimum Particle Size" : 100 : "This value determines the minimum size the particles can be."
	SizeMax(string) : "Maximum Particle Size" : 200 : "This value determines the maximum size the particles can be."
	FallSpeed(integer) : "Particle Fall Speed" : : "How fast the particles fall to the ground."	

	Frozen(boolean) : "Frozen?" : 0 : "When set, this entity spawns the number of particles in 'Particle Per Second' immediately, and then goes inactive."

	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"
	
	input TurnOn(void) : "Turn on."
	input TurnOff(void) : "Turn off."
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]


// have to merge BaseEntityBrush into this as the origin keyvalue breaks stuff, unfortunately
@SolidClass = func_dustmotes : 
	"A brush entity that spawns sparkling dust motes within its volume. Affected by env_wind."
[
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."

	effects(choices) : "Effect flags" : 0 : "For configuring visual effects. If you want to combine effects, turn SmartEdit off and add the effect numbers together, i.e. 64 + 8 = 72." =
	[
		0 : "None"
		1 : "Bonemerge, very expensive!!"
		2 : "Bright, dynamic light at entity origin"
		4 : "Dim, dynamic light at entity origin"
		8 : "No movement interpolation"
		16 : "Don't cast shadows"
		32 : "Don't draw entity (entity is fully ignored by clients, NOT server)"
		64 : "Don't receive dynamic shadows"
		128 : "Bonemerge only in PVS, better performance but prone to disappearing. Use with Bonemerge."
		256 : "Blinking glow"
		512 : "Flag parent as always animating and realign each frame"
		// Portal 2 and later only
//      1024 : "Mark for fast reflections"
//      2048 : "No shadow depth, for use with env_cascade_light"
//      4096 : "No projected textures"
	]
	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	
	linedivider2(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	StartDisabled(boolean) : "Start Disabled?" : 0 : "Don't create particles when spawned."
	
	Color(color255) : "Particle Color (R G B)" : "255 255 255" : "Color of the particles."
	Alpha(integer) : "Particle Translucency (0 - 255)" : 30 : "Transluceny of the particles."
	SpawnRate(integer) : "Particle Per Second" : 40 : "Number of particles to spawn, per second."
	SpeedMax(string) : "Maximum Particle Speed" : 13 : "Maximum speed that the particles can move after spawning."
	LifetimeMin(string) : "Minimum Particle Lifetime" : 3 : "Minimum number of seconds until each particle dies. Particles live for a random duration between this and 'Maximum Particle Lifetime'."
	LifetimeMax(string) : "Maximum Particle Lifetime" : 5 : "Maximum number of seconds until each particle dies. Particles live for a random duration between 'Minimum Particle Lifetime' and this."
	DistMax(integer) : "Maximum Visible Distance" : 1024 : "Maximum distance at which particles are visible. They fade to translucent at this distance."
	SizeMin(string) : "Minimum Particle Size" : 100 : "This value determines the minimum size the particles can be."
	SizeMax(string) : "Maximum Particle Size" : 200 : "This value determines the maximum size the particles can be."
	FallSpeed(integer) : "Particle Fall Speed" : : "How fast the particles fall to the ground."
		
	Frozen(boolean) : "Frozen?" : 0 : "When set, this entity spawns the number of particles in 'Particle Per Second' immediately, and then goes inactive."
	
	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"
	
	input TurnOn(void) : "Turn on."
	input TurnOff(void) : "Turn off."
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."

]

@PointClass base(BaseEntity, Angles) sphere(max_range) iconsprite("editor-ficool2/func_fish_pool") = func_fish_pool :
    "Creates a school of interactive fish that swim near this entity on the Y axis only. Killing the func_fish_pool does not delete the fish, the fish entity can be killed as a workaround."+
 	"However, killing the fish entity before killing the func_fish_pool entity crashes the game, the func_fish_pool entity must be killed first."
[
	model(studio) : "Fish Model" : : " The fish model."
	fish_count(integer) : "Fish Count" : 10 : "Number of fish in this pool."
	max_range(float) : "Max Range (1 - 255)" : 150 : "How far away a fish can wander, maximum is 255 units."
]

@SolidClass base(func_brush, TeamNum) = func_forcefield : 
	"A brush entity that is only solid to players on a specified team. Unlike func_respawnroomvisualizer, this entity remains visible to both teams regardless of distance." 
[
]

@SolidClass base(BaseAnimatingBrush) = func_guntarget :
	"This is a moving target that moves along a path of path_tracks. It can be shot and killed."
[
	speed(integer) : "Speed (units per second)" : 100 : "The speed at which the target moves along its path."
	target(target_destination) : "First Stop" : : "The name of the first path_track entity in the path that this target should follow."
	health(integer) : "Damage to Take" : 0 : "The amount of damage taken before this target is killed."
	
	input Start(void) : "Start the target to move."
	input Stop(void) : "Stop the target from moving."
	input Toggle(void) : "Toggle the target between moving and stopped."
	
	output OnDeath(void) : "Fires when the target is killed."
]

@SolidClass base(BaseAnimatingBrush) = func_illusionary : 
	"Legacy support. Use func_brush instead. A basic brush entity which has no collisions to anything." 
[
]

@SolidClass = func_ladder : 
	"Internal entity. A ladder. Players will be able to freely move along this brush, as if it was a ladder. "+
	"If you are using a model prop for the visual representation of the ladder in the map, apply the toolsinvisibleladder material to the func_ladder brush. "+
	"Does not function in Team Fortress 2."
[
]

@PointClass base(BaseEntity) size( -16 -16 0, 16 16 72 ) color(127 127 127) = func_ladderendpoint : 
	"An entity used to specify the endpoints of a ladder. This entity is functional, but has been replaced by the " + 
	"easier-to-use func_useableladder entity. Left in only for backwards-compatibility!\n\n" +
	"To be valid, a full sized player hull traced between the start and end points must not be obstructed at level " + 
	"activation time. The angle determines in which direction the player leaves the ladder if the player presses the " +
	"+jump button. Does not function in Team Fortress 2."
[
	target(target_destination) : "Other Endpoint" : : "A ladder goes between any two func_ladderendpoints pointing at each other."
]

@SolidClass base(BaseAnimatingBrush) sphere(DisappearDist) = func_lod : 
	"Brush-built model that fades out over a specified distance. Useful for creating world detail that doesn't need to be drawn far away, for performance reasons."
[
	DisappearDist(integer)    : "Disappear Distance" : 2000 : "Distance at which these brushes should fade out."
]

@SolidClass base(func_brush) = func_monitor :
	"A monitor that renders the view from a given point_camera entity. Does not work in Team Fortress 2."
[
	target(target_destination) : "Camera Name" : : "Name of the camera to render."
	
	input Toggle(void) : "Toggle the monitor."
	input Enable(void) : "Enable the monitor."
	input Disable(void) : "Disable the monitor."
	input SetCamera(string) : "Sets the camera to use for this monitor. Takes the name of a point_camera entity in the map."
]

@SolidClass base(BaseAnimatingBrush) = func_movelinear :
	"A brush entity that moves linearly along a given distance, in a given direction."
[
	movedir(angle) : "Move Direction (Pitch Yaw Roll)" : "0 0 0" : "The direction the brushes will move, when told to."
	spawnflags(flags) =
	[
		8 : "Not Solid (does not allow physically-simulated objects to be parented however)" : 0
	]

	startposition(float) : "Start Position" : 0 : "Position of brush when spawned. The range is a value between 0.0 and 1.0, where 0 is the starting position and 1 is the starting position + (move direction * move distance)."	
	speed(integer) : "Speed" : 100 : "The speed that the brush moves, in units per second."
	movedistance(float) : "Move Distance" : 100 : "The distance from the starting point that the brush should move, in units."
	blockdamage(float) : "Block Damage" : 0 : "The amount of damage to do to any entity that blocks the brushes, per frame."
	startsound(sound) : "Sound played when the brush starts moving."
	stopsound(sound) : "Sound played when the brush stops moving."

	input Open(void) : "Move the brush to the end position (starting position + (move direction * move distance))."
	input Close(void) : "Move the brush to the starting position."
	input SetPosition(string) : "Move the brush to a specific position between 0.0 and 1.0, where 0 is the starting position and 1 is the starting position + (move direction * move distance). Negative values are accepted and values above 1.0 and -1.0 will move in multiples of the set Move Distance."
	input SetSpeed(float) : "Set the speed and update immediately."

	output OnFullyOpen(void) : "Fired when the brush reaches the end position (starting position + (move direction * move distance))."
	output OnFullyClosed(void) : "Fired when the brush reaches the starting position."
]

@SolidClass base(Trigger) = func_nobuild : 
    "A func_nobuild entity will restrict an Engineer from building in the specific area it contains. "
[
]

@SolidClass base(Trigger, TeamNum) = func_nogrenades :
	"This brush will destroy any explosive projectile that touches it and nullifies explosive damage."
[
]

@SolidClass base(BaseAnimatingBrush) = func_pendulum : 
   "Swings back and forth." 
[
	speed(integer) : "Speed" : 100
	pendistance(integer) : "Distance (deg)" : 90
	damp(integer) : "Damping (0-1000)" : 0
	dmg(integer) : "Damage inflicted when blocked" : 0

	spawnflags(flags) =
	[
		1: "Start ON" : 0
		8: "Passable" : 0
		16: "Auto-return" : 0
		64: "X Axis" : 0
		128: "Y Axis" : 0
	]
]

@SolidClass base(BaseEntity) color(50 50 255) = func_occluder :
	"A occluder brush used to manage dynamic visibility in maps. Occluders are used to dynamically " +
	"determine what things are behind them, to prevent trying to draw them at all."
[
	StartActive(choices) : "Initial State?" : 1 : "If the entity starts inactive, use the Activate or Toggle inputs to turn it on." =
	[
		0 : "Inactive"
		1 : "Active"
	]
	
	input Deactivate(void) : "Deactivate the occluder, When inactive, it can be seen through."
	input Activate(void) : "Activate the occluder. When active, it cannot be seen through."
	input Toggle(void) : "Toggle the active/inactive state of the occluder."
]

@SolidClass base(BreakableBrush) sphere(exploderadius) = func_physbox : 
	"A brush entity that is physically simulated."
[
	massScale(float) : "Mass Scale" : "0" : "A scale multiplier for the object's mass. Use the convar sv_massreport 1 to see the actual mass of the object ingame."
	Damagetype(choices) : "Impact Damage Type" : "Blunt" : "Sets the 'sharpness' of the brush. Sharp objects are far more damaging." =
	[
		"0": "Blunt"
		"1": "Sharp"
	]
	overridescript(string) : "Override Parameters" :  : "A list of physics key/value pairs that are usually in a physics prop .qc file. Format is 'key,value,key,value,etc'."
	damagetoenablemotion(integer) : "Health Level to Override Motion" : 0 : "If specified, this object will start motion disabled. Once its health has dropped below this specified amount, it will enable motion."
	forcetoenablemotion(float) : "Physics Impact Force to Override Motion" : 0 : "If specified, this object will start motion disabled. Any impact that imparts a force greater than this value on the physbox will enable motion."
	health(integer) : "Health/Strength" : 0 : "Number of points of damage to take before breaking.  0 means don't break."
	preferredcarryangles(vector) : "Preferred Player-carry Angles" : "0 0 0" : "If the 'Use Preferred Carry Angles' spawnflag is set, this angle is the angle which the object should orient to when the player picks it up, with the physgun or +USE."
	nodamageforces(boolean) : "Damaging it Doesn't Push It?" : 0 : "Used to determine whether or not damage should cause the brush to move."
	
	notsolid(choices) : "Solidity" : 0 : "If set, the object will pass through world geometry." =
	[
		0: "Solid to World"
		1: "Passes through World"
	]

	spawnflags(flags) =
	[
		4096  : "Start Asleep" : 0
		8192  : "Ignore +USE for Pickup" : 0
		16384 : "Debris - Don't collide with the player or other debris" : 0
		32768 : "Motion Disabled" : 0
		65536 : "Use Preferred Carry Angles" : 0
		131072: "Enable motion on Physcannon grab" : 0
		262144: "Not affected by rotor wash" : 0
		524288: "Generate output on +USE " : 1
		1048576 : "Physgun can always pick up. No matter what." : 0
		2097152 : "Physgun is NOT allowed to pick this up." : 0 
		4194304 : "Physgun is NOT allowed to punt this object." : 0
		8388608: "Prevent motion enable on player bump" : 0
	]
	
	input Wake(void) : "Wake up this physics object, if it is sleeping."
	input Sleep(void) : "Put this physics object to sleep. It will wake if given the Wake input, or if force is applied to it. Note that physics objects go to sleep automatically after coming to rest for a while, so you don't really need to use this."
	input EnableMotion(void) : "Enable physics motion/collision response."
	input DisableMotion(void) : "Disable physics motion/collision response."
	input DisableFloating(void) : "Disables the object from floating."
	input ForceDrop(void) : "If this object is being carried by a player, with the physgun or +USE, force it to be dropped."
	
	output OnDamaged(void) : "Fired when this entity is damaged."
	output OnAwakened(void) : "Fired when this entity becomes awake (collision/force is applied)."
	output OnMotionEnabled(void) : "Fired when motion is enabled due to damage/physcannon/force."
	output OnPhysGunPickup(void) : "Fired when a player picks this object up, either with the physgun or +USE."
	output OnPhysGunPunt(void) : "Fired when a player punts this object with the physgun."
	output OnPhysGunOnlyPickup(void) : "Fired when a player picks this object up WITH THE PHYSGUN. +USE pickups do not fire this output."
	output OnPhysGunDrop(void) : "Fired when a player drops this object."
	output OnPlayerUse(void) : "Fired when the player tries to +USE the physbox. This output will fire only if the Generate output on +USE spawnflag is set."
]

// copying over func_physbox as its not worth an independant base
@SolidClass base(BreakableBrush) sphere(exploderadius) = func_physbox_multiplayer : 
	"This class is the same as func_physbox, except the runtime collisions use a more bouncy method that avoids " +
	"the prediction errors normal physics objects get. Use when possible!"
[
	massScale(float) : "Mass Scale" : "0" : "A scale multiplier for the object's mass. Use the convar sv_massreport 1 to see the actual mass of the object ingame."
	Damagetype(choices) : "Impact Damage Type" : "Blunt" : "Sets the 'sharpness' of the brush. Sharp objects are far more damaging." =
	[
		"0": "Blunt"
		"1": "Sharp"
	]
	overridescript(string) : "Override Parameters" :  : "A list of physics key/value pairs that are usually in a physics prop .qc file. Format is 'key,value,key,value,etc'."
	damagetoenablemotion(integer) : "Health Level to Override Motion" : 0 : "If specified, this object will start motion disabled. Once its health has dropped below this specified amount, it will enable motion."
	forcetoenablemotion(float) : "Physics Impact Force to Override Motion" : 0 : "If specified, this object will start motion disabled. Any impact that imparts a force greater than this value on the physbox will enable motion."
	health(integer) : "Health/Strength" : 0 : "Number of points of damage to take before breaking.  0 means don't break."
	preferredcarryangles(vector) : "Preferred Player-carry Angles" : "0 0 0" : "If the 'Use Preferred Carry Angles' spawnflag is set, this angle is the angle which the object should orient to when the player picks it up, with the physgun or +USE."
	nodamageforces(boolean) : "Damaging it Doesn't Push It" : 0 : "Used to determine whether or not damage should cause the brush to move."
	
	notsolid(choices) : "Solidity" : 0 : "If set, the object will pass through world geometry." =
	[
		0: "Solid to World"
		1: "Passes through World"
	]

	spawnflags(flags) =
	[
		4096  : "Start Asleep" : 0
		8192  : "Ignore +USE for Pickup" : 0
		16384 : "Debris - Don't collide with the player or other debris" : 0
		32768 : "Motion Disabled" : 0
		65536 : "Use Preferred Carry Angles" : 0
		131072: "Enable motion on Physcannon grab" : 0
		262144: "Not affected by rotor wash" : 0
		524288: "Generate output on +USE " : 1
		1048576 : "Physgun can always pick up. No matter what." : 0
		2097152 : "Physgun is NOT allowed to pick this up." : 0 
		4194304 : "Physgun is NOT allowed to punt this object." : 0
		8388608: "Prevent motion enable on player bump" : 0
	]
	
	input Wake(void) : "Wake up this physics object, if it is sleeping."
	input Sleep(void) : "Put this physics object to sleep. It will wake if given the Wake input, or if force is applied to it. Note that physics objects go to sleep automatically after coming to rest for a while, so you don't really need to use this."
	input EnableMotion(void) : "Enable physics motion/collision response."
	input DisableMotion(void) : "Disable physics motion/collision response."
	input DisableFloating(void) : "Disables the object from floating."
	input ForceDrop(void) : "If this object is being carried by a player, with the physgun or +USE, force it to be dropped."
	
	output OnDamaged(void) : "Fired when this entity is damaged."
	output OnAwakened(void) : "Fired when this entity becomes awake (collision/force is applied)."
	output OnMotionEnabled(void) : "Fired when motion is enabled due to damage/physcannon/force."
	output OnPhysGunPickup(void) : "Fired when a player picks this object up, either with the physgun or +USE."
	output OnPhysGunPunt(void) : "Fired when a player punts this object with the physgun."
	output OnPhysGunOnlyPickup(void) : "Fired when a player picks this object up WITH THE PHYSGUN. +USE pickups do not fire this output."
	output OnPhysGunDrop(void) : "Fired when a player drops this object."
	output OnPlayerUse(void) : "Fired when the player tries to +USE the physbox. This output will fire only if the Generate output on +USE spawnflag is set."
]

@SolidClass base(BaseAnimatingBrush) = func_plat :
	"A brush entity that moves vertically."
[
	spawnflags(flags) =
	[
		1: "Toggle" : 1
	]
	noise1(sound) : "Movement Sound" : : "The sound to play when the brush moves."
	noise2(sound) : "Stop Sound" : : "The sound to play when the brush stops moving."
	volume(float) : "Sound Volume [0 - 10]" : "5" : "The volume of the sounds, 0 is no sound and 10 is loudest."
	speed(float) : "Speed" : "50" : "Speed at which the brush moves"
	lip(float) : "Lip" : "0" :	"The amount, in units, of the platform to leave sticking out of the wall it recedes into when pressed. Negative values make the platform recede even further into the wall."
	wait(float) : "Wait Time" : :	"How long to wait before moving again. -1 will wait forever."
	height(float) : "Height" : "0" :	"The extra height offset upon spawning."
									
 	input Toggle(void) : "Toggles the platform's state."
	input GoUp(void) : "Tells the platform to go up."
	input GoDown(void) : "Tells the platform to go down."
]

@SolidClass base(BaseAnimatingBrush) = func_platrot : 
	"A brush entity that moves vertically, and can rotate while doing so." 
[
	spawnflags(Flags) =
	[
		1: "Toggle" : 1
		64: "X Axis" : 0
		128: "Y Axis" : 0
	]
	noise1(sound) : "Movement Sound" : : "The sound to play when the brush moves."
	noise2(sound) : "Stop Sound" : : "The sound to play when the brush stops moving."
	volume(float) : "Sound Volume [0 - 10]" : "5" : "The volume of the sounds, 0 is no sound and 10 is loudest."
	speed(integer) : "Speed of Rotation" : 50 : "Speed at which the brush rotates, in degrees per second."
	height(integer) : "Travel Altitude" : 0 : "The vertical distance from the starting position that this platform moves. If negative, the platform will lower."
	rotation(integer) : "Spin amount" : 0 : "The amount this platform should rotate as it moves, in degrees."
	lip(float) : "Lip" : "0" :	"The amount, in units, of the platform to leave sticking out of the wall it recedes into when pressed. Negative values make the platform recede even further into the wall."
	wait(float) : "Wait Time" : :	"How long to wait before moving again. -1 will wait forever."
	
 	input Toggle(void) : "Toggles the platform's state."
	input GoUp(void) : "Tells the platform to go up."
	input GoDown(void) : "Tells the platform to go down."
]

@SolidClass base(BaseEntityBrush) = func_precipitation : 
	"A brush entity that creates rain, snow, or ash inside its volume."+
	"Warning: func_precipitation volumes shouldn't be placed in the same volume as func_smokevolume is, as it will invoke a crash."
[
	renderamt(integer) : "Density (0 - 100%)" : 5 : "This is the amount of particles that fall down from top side of brush. However distance from first particle to second depends on a brush volume size!"
	rendercolor(color255) : "Color (R G B)" : "100 100 100" : "Color added to sprites which are rendered transparently (probably rain and snow particles)"
	preciptype(choices) : "Precipitation Type" : 0 =	
	[
		0 : "Rain"
		1 : "Snow"
		2 : "Ash"
		3 : "Snowfall"
	]
	
	input Alpha(void) : "Changes the density of the rain, and may add additional particle effects like fog or leafs. Accepts inputs from -1 to 255."
]

@SolidClass base(BreakableBrush) sphere(exploderadius) = func_pushable :
    "A pushable brush object with very primitive physics. Only moveable with +USE inputs by player."
[
	size(choices) : "Hull Size" : 0 =
	[
		0: "Point size"
		1: "Player size"
		2: "Big Size"
		3: "Player duck"
	]

	spawnflags(flags) =
	[
		128: "Breakable" : 0
	]
	
	target(target_destination) : "Target on Break" :  : "What entity to fire an input to when this brush breaks."
	friction(integer) : "Friction (0-400)" : 50 : "The amount of friction in the brush."
	buoyancy(integer) : "Buoyancy" : 20 : "The amount of buoyancy in the brush."
]

@SolidClass base(func_brush) = func_reflective_glass :
	"Used to produce perfectly reflective glass that renders the world + entities. Only 1 side of the brush can be reflective." +
	"Warning: cannot be used together with scenes that have water, and you can only " +
	"have 1 reflective glass in your view frustum ( + pvs ) at a time. Players will not see their own reflection unless they are in thirdperson mode."
[
]

@SolidClass base(Trigger, TeamNum) = func_regenerate :
	"Regeneration/item resupply zone for players."
[
	associatedmodel(target_destination) : "Associated Model" :  : "The prop_dynamic that represents this zone in the world. The associated model should have appropriate open and close animations for when players interact with the zone."
]

@SolidClass base(Trigger) = func_respawnflag :
	"Designates an area that triggers the flag to reset when it touches the area." 
[
]

@SolidClass base(Trigger, TeamNum) = func_respawnroom :
	"Designates a respawn room for a team."
[
	input SetActive(void) : "Sets the respawn room as active."
	input SetInactive(void) : "Sets the respawn room as inactive."
	input ToggleActive(void) : "Toggles the respawn room between active and inactive."
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
]

@SolidClass base(func_brush) = func_respawnroomvisualizer : 
	"Brushes that become visible to enemy players when they get close. Use them to mark areas that they're unable to enter (i.e. respawn rooms)." 
[
	respawnroomname(target_destination) : "Associated Respawn Room" :  : "The func_respawnroom that this entity is visualizing. This entity will have its team matched to that for the func_respawnroom, and will have it updated if the func_respawnroom ever changes team."
	
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
]

@SolidClass base(BaseAnimatingBrush) = func_rot_button : 
	"A brush entity that's designed to be used for a rotating player-useable button. When used by the player, it rotates to a pressed position."
[
	speed(integer) : "Speed" : 50 : "The speed that the button rotates, in degrees per second."
	health(integer) : "Health" : 0 : "Legacy method of specifying whether or not the button can be shot to activate it."
	wait(integer) : "Delay Before Reset (-1 stay)" : 3 : "Amount of time, in seconds, after the button has been pressed before it returns to the starting position. Once it has returned, it can be used again. If the value is set to -1, the button never returns."
	distance(integer) : "Distance (deg)" : 90 : "The amount, in degrees, that the button should rotate when it's pressed."
	health(integer) : "Health" : 0 : "Legacy method of specifying whether or not the button can be shot to activate it. Use the 'Damage Activates' spawnflag instead."

	sounds(choices) : "Button Sound" : 0 : "Button sounds. Not all sounds will work in all games!" = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]	

	locked_sound(choices) : "Locked Sound" : 0 : "Sound played when the player tries to use the button, and fails because it's locked." = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]
	unlocked_sound(choices) : "Unlocked Sound" : 0 : "Sound played when the button is unlocked." = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]
	
	spawnflags(flags) =
	[
		1 : "Not Solid" : 0
		2 : "Reverse Direction" : 0
		32: "Toggle" : 1
		64: "X Axis" : 0
		128: "Y Axis" : 0
		256: "Touch Activates": 0
		512: "Damage Activates": 1
		1024: "Use Activates" : 1
		2048: "Starts locked" : 0
		4096: "Sparks" : 0
	]
		
	input Lock(void) : "Lock the button, preventing it from functioning."
	input Unlock(void) : "Unlock the button, allowing it to function."
	input Press(void) : "Activate the button as if it was pressed."
	input PressIn(void) : "Activate the button as if it was pressed, sending it to the bottom position."
	input PressOut(void) : "Unpress the button, sending it to the top position."
	
	output OnDamaged(void) : "Fired when the button is damaged."
	output OnPressed(void) : "Fired when the button is pressed."
	output OnUseLocked(void) : "Fired when the button is used while locked."
	output OnIn(void) : "Fired when the button reaches the in/pressed position."
	output OnOut(void) : "Fired when the button reaches the out/released position."
]

@SolidClass base(BaseAnimatingBrush) = func_rotating : 
	"A rotating brush entity. Due to a bug with the Clientside Rotation flag, you need to do a small tweak: https://tf2maps.net/posts/451480/"
[
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."
	maxspeed(integer) : "Max Rotation Speed" : 100 : "The maximum rotation speed of the brushes, in degrees per second."
	fanfriction(integer) : "Friction (0 - 100%)" : 20 : "The amount of rotational friction. Value must be between 0 and 100 %."
	message(sound) : "Rotating Sound" : : "Sound to play while rotating."
	volume(integer) : "Volume (10 = loudest)" : 10 : "The volume of the rotation sound."
	dmg(integer) : "Blocking Damage" : 0 : "Damage done to any entity that blocks the rotation, per frame."

	solidbsp(choices) : "Solid Type" : 1 : "Brush solidity type" =
	[
		0 : "VPhysics"	
		1 : "BSP"
	]

	spawnflags(flags) =
	[
		1 : "Start ON"  : 0
		2 : "Reverse Direction" : 0
		4 : "X Axis - Spin at the Y axis"  : 0
		8 : "Y Axis - Spin at the X axis"  : 0
		16: "Clientside Rotation" : 1
		32: "Fan Pain - Player will be hurt when coming into contact with the brush" : 0
		64: "Not Solid" : 0
		128: "Small Sound Radius" : 0
		256: "Medium Sound Radius" : 0
		512: "Large Sound Radius" : 1
	]

	input SetSpeed(integer) : "Set the speed as a ratio of the specified Max Rotation Speed, where 0 is stopped and 1 is the Max Rotation Speed."
	input Start(void) : "Start the rotator rotating."
	input Stop(void) : "Stop the rotator from rotating."
	input StopAtStartPos(void) : "Stop the rotator from rotating when it gets around to the start position again (on its rotation axis)."
	input StartForward(void) : "Start the rotator rotating forward."
	input StartBackward(void) : "Start the rotator rotating backward."
	input Toggle(void) : "Toggle the rotator between rotating and not rotating."
	input Reverse(void) : "Reverse the direction of rotation of the rotator."
]

// Inherting BaseEntityBrush WITHOUT origin, as for some reason that breaks the entire entity
@SolidClass = func_smokevolume : 
	"A brush entity that spawns smoke particles within its volume. Can also be used as a trigger. Should not be placed in a func_precipitation, as it will cause crashes."
[
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	parentname(target_destination) : "Parent" : : "Specifies a movement parent. An entity will maintain its initial offset from its parent. An attachment point can be added to the end of the name, separated by a comma. Every entity can be parented, even point entities. Entities which are parented will be forced to transition to the next map, such as from a trigger_transition. Some entities which aren't intended to be parented may not function correctly. phys_constraint can be used as a workaround to parenting."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."

	linedivider1(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	solid(choices) : "Collisions" : : "Method of collision for this entity. Can be changed at runtime with AddOutput." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	
	linedivider2(string) readonly : "----------------------------------------------------------------------------------------------------------" : ""

	Color1(color255) : "Particle Color1 (R G B)" : "255 255 255" : "Color to use for particles."
	Color2(color255) : "Particle Color2 (R G B)" : "255 255 255" : "Secondary color to use for particles."
	material(material) : "Material" : "particle/particle_smokegrenade" : "The material to use for the particles."
	ParticleDrawWidth(float) : "Particle Draw Width (units)" : 120 : "The size of the particles, in units/units."
	ParticleSpacingDistance(float) : "Particle Spacing Distance (units)" : 80 : "The distance between the particles inside the volume. The lower the number, the denser the particles, and the more overdraw there will be. It is best to keep it as high as you can without it looking bad."
	Density(float) : "Density [0..1]" : 1
	DensityRampSpeed(float) : "Density Ramp Speed (seconds)" : 1 : "Time to go from density 0 to density 1, in seconds."
	RotationSpeed(float) : "Rotation Speed (degrees/sec)" : 10 : "The speed that the particles should rotate, in degrees per second."
	MovementSpeed(float) : "Movement Speed (units/sec)" : 10 : "The speed that the particles should move around, in units/units per second."

	spawnflags(flags) =
	[
		1 : "Emissive - Changes how the smoke particles are drawn. Emissive is 4 times more expensive to render, but prettier." : 0
	]
	
	input Kill(void) : "Removes this entity and all its children from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world. Faster than sending the Kill input on entities with children."
	
	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."	
	
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 = infinite, 1 = only once)>. "
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."	
	input Use(void) : "Same as a player invoking +use; may not do anything. Can also be invoked by creating an output that does not specify an input."
	input DispatchEffect(string) : "Dispatch an effect from the entity's origin. See https://developer.valvesoftware.com/wiki/List_of_Client_Effects"

	input SetRotationSpeed(float) : "Set the particle rotation speed (in degrees per second)."
	input SetMovementSpeed(float) : "Set the particle movement speed (in units per second)."
	input SetDensity(float) : "Set the particle density. It should be a range from 0 to 1."
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]


@SolidClass base(BaseTrain) = func_tanktrain :
	"A moving tank that follows a path of path_track entities, shoots at the player, and can be killed.\n" + 
	"NOTE: Build your train so that the front of the train is facing down the X axis. " +
	"When it spawns it will automatically rotate to face the next path_track on the path." +
	"WARNING: The tank will never die, as it was poorly coded!"
[
	health(integer) : "Health" : 100 : "Health of the tank. Does not function."
	
	output OnDeath(void) : "Fired when the tank is killed, does not function as the tank is unable to die."
]

@SolidClass base(BaseAnimatingBrush) = func_trackautochange : 
	"An entity that works as a rotating/moving platform that will carry a train to a new track. "+
	"It must be larger in X-Y planar area than the train, since it must contain the train within "+
	"these dimensions in order to operate when the train is near it. The track will rotate around its own origin. "+
	"This entity will only allowed to be triggered if the train is on a path_track which is a dead end. "+
	"If Auto Activate Train flag is ticked, train isn't paused at the top/bottom of the path after func_trackautochange has finished it's movement. Instead, it will continue moving forward and doesn't need to be reactivated by trigger. "+
	"If selected, the platform only rotates in place of it's origin without travelling specified altitude. The top and the bottom path_tracks should have their origin positioned in the same coordinates."
[
	height(integer) : "Travel Altitude" : 0 : "Travel distance, from top to bottom. If Start at Bottom flag is selected, the travel distance won't change from bottom to top, it will only make the platform start at bottom and awaits for func_tracktrain to arrive."
	rotation(integer) : "Spin amount" : 0 : "The amount this platform should rotate as it moves, in degrees."
	train(target_destination) : "Train to Switch" : : "Name of func_tracktrain this platform will transport to top/bottom track."	
	toptrack(target_destination) : "Top Track" : : "Name of last path_track of the top path (if Start at Bottom flag is selected, this is the name of the first path_track at the top path)."			 	
	bottomtrack(target_destination) : "Bottom Track" : : "Name of first path_track of the bottom track (if Start at Bottom flag is selected, this is the name of the last path_track at the bottom path)."
	speed(integer) : "Move/Rotate Speed" : 0 : "Speed in which func_trackautochange travel the whole way up/down (units per seconds)."			
	
	spawnflags(flags) =
	[
		1: "Auto Activate Train - see description" : 0
		2: "Relink Track" : 0
		8: "Start at Bottom - Platform starts at the bottom instead at the top path_track if this flag is ticked" : 0
		16: "Rotate Only - see description" : 0
		64: "X Axis - Train rotates around X axis instead of Z axis. Can be combined with Y Axis" : 0
		128: "Y Axis - Train rotates around Y axis instead of Z axis. Can be combined with X Axis" : 0
	]

	input Trigger(void) : "Trigger the track change. The train must be currently on a dead end of a path_track."
]

@SolidClass base(BaseAnimatingBrush) = func_trackchange : 
	"An entity that works as a rotating/moving platform that will carry a train to a new track. "+
	"It must be larger in X-Y planar area than the train, since it must contain the train within "+
	"these dimensions in order to operate when the train is near it. The track will rotate around its own origin. "+
	"Similar variant to this entity is func_trackautochange, however you can't trigger func_trackautochange unless the path_track is a dead end. "+
	"If Auto Activate Train flag is ticked, train isn't paused at the top/bottom of the path after func_trackchange has finished it's movement. Instead, it will continue moving forward and doesn't need to be reactivated by trigger. "+
	"If selected, the platform only rotates in place of it's origin without travelling specified altitude. The top and the bottom path_tracks should have their origin positioned in the same coordinates."
[
	height(integer) : "Travel Altitude" : 0 : "Travel distance, from top to bottom. If Start at Bottom flag is selected, the travel distance won't change from bottom to top, it will only make the platform start at bottom and awaits for func_tracktrain to arrive."
	rotation(integer) : "Spin amount" : 0 : "The amount this platform should rotate as it moves, in degrees."
	train(target_destination) : "Train to Switch" : : "Name of func_tracktrain this platform will transport to top/bottom track."	
	toptrack(target_destination) : "Top Track" : : "Name of last path_track of the top path (if Start at Bottom flag is selected, this is the name of the first path_track at the top path)."			 	
	bottomtrack(target_destination) : "Bottom Track" : : "Name of first path_track of the bottom track (if Start at Bottom flag is selected, this is the name of the last path_track at the bottom path)."
	speed(integer) : "Move/Rotate Speed" : 0 : "Speed in which func_trackchange travel the whole way up/down (units per seconds)."			
	
	spawnflags(flags) =
	[
		1: "Auto Activate Train - see description" : 0
		2: "Relink Track" : 0
		8: "Start at Bottom - Platform starts at the bottom instead at the top path_track if this flag is ticked" : 0
		16: "Rotate Only - see description" : 0
		64: "X Axis - Train rotates around X axis instead of Z axis. Can be combined with Y Axis" : 0
		128: "Y Axis - Train rotates around Y axis instead of Z axis. Can be combined with X Axis" : 0
	]

	input Trigger(void) : "Trigger the track change."
]

@SolidClass base(BaseTrain) = func_tracktrain :
	"A moving platform that the player can ride. It follows a path of path_track entities.\n" +
	"NOTE: Build your train so that the front of the train is facing down the X axis. " +
	"When it spawns it will automatically rotate to face the next path_track on the path."
[
]

@SolidClass base(BaseAnimatingBrush) = func_train
[
	target(target_destination) : "Target" : : "The name of the first path_track in the train's path."
	noise1(sound) : "Movement Sound" : : "The sound to play when the train moves."
	noise2(sound) : "Stop Sound" : : "The sound to play when the train stops moving."
	speed(float) : "Speed" : "50" : "Speed at which the brush moves."
	volume(float) : "Sound Volume [0 - 10]" : "5" : "Volume of the sound when moving. 0 is no sound, 10 is full loudness."
	dmg(float) : "Crush Damage" : "0" : "Damage applied to any entity obstructing the path."
	wait(float) : "Wait Time" : :	"How long to wait before moving again. -1 will wait forever."
	height(float) : "Height" : :	"The extra height offset upon spawning."
	
	spawnflags(flags) =
	[
		8 : "Non-Solid" : 0
	]

	input Toggle(void) : "Toggle movement between start and stop."
	input Start(void) : "Start movement."
	input Stop(void) : "Stop movement."
	input Use(void) : "Toggle movement - the train will move only when the input is triggered."
]

@SolidClass base(BaseAnimatingBrush) = func_traincontrols :
	"When +USEd by the player, this entity overrides the player's controls to let them drive a train"
[
	target(target_destination) : "Train Name" : : "The target train to control when the player uses these controls."
]

@PointClass base(BaseEntity) sweptplayerhull() = func_useableladder : 
	"A Half-Life 2-style ladder. Handles player auto mount/unmount, as well as +USE to get onto the ladder. \n\n" +
	"See also 'info_ladder_dismount', used to specify ladder auto-dismount points."
[
	point0(vector) : "Start" : : "Ladder end point."
	point1(vector) : "End" : : "Ladder end point."

	ladderSurfaceProperties(string) : "Surface properties (optional)"

	StartDisabled(boolean) : "Start Disabled?" : 0

	spawnflags(flags) =
	[
		1: "Fake Ladder" : 0
	]
	
	input Enable(void) : "Enable this ladder."
	input Disable(void) : "Disable this ladder."

	output OnPlayerGotOnLadder(void) : "Fired whenever a player gets on this ladder."
	output OnPlayerGotOffLadder(void) : "Fired whenever a player gets off this ladder."
]

@SolidClass base(BaseEntityBrush) = func_vehicleclip: 
    "Acts as a functional clip or barrier affecting vehicle entities, such as prop_vehicle_driveables. Should be used with the tools/toolscontrolclip texture." 
[
	input Enable( void ) : "Enable collisions with vehicles."
	input Disable( void ) : "Disable collisions with vehicles."
]

@SolidClass color(180 180 0) = func_viscluster : 
	"Any leaves touching this brush will have their visibility merged together into a single cluster.  Use multiple func_viscluster entities to reduce VVIS time."
[
]

@SolidClass base(BaseAnimatingBrush) = func_wall : 
	"Legacy support for Half-Life. Use func_brush instead. A general brush entity." 
[
]

@SolidClass base(func_wall) = func_wall_toggle : 
	"Legacy Support for Half-Life. Use func_brush instead. A general brush entity which can be toggled." 
[
	spawnflags(flags) =
	[
		1 : "Starts Invisible" : 0
	]

	input  Toggle(void) : "Toggle the brush on/off. When off, the brush will be non-solid and invisible." 
]

@SolidClass base(Door) = func_water : 
	"Legacy support for Half-Life. Same functionality as func_water_analog although this entity has everything borrowed from func_door."
[
	movedir(angle) : "Move Direction (Pitch Yaw Roll)" : "0 0 0" : "The direction the door will move, when it opens."
]

@SolidClass base(BaseAnimatingBrush) = func_water_analog :
	"A water brush entity that moves linearly along a given distance, in a given direction, similiarly to func_mo"
[
	movedir(angle) : "Move Direction (Pitch Yaw Roll)" : "0 0 0" : "The direction the water will move, when told to 'Open'."
	startposition(float) : "Start Position" : 0 : "Position of the water brush when spawned. The range is a value between 0.0 and 1.0, where 0 is the starting position and 1 is the starting position + (move direction * move distance)."	
	speed(integer) : "Speed" : 100 : "The speed that the water brush moves, in units per second."
	movedistance(float) : "Move Distance" : 100 : "The distance from the starting point that the water brush should move, in units."
	startsound(sound) : "Start Sound" : : "Sound played when the water brush starts moving."
	stopsound(sound) : "Stop Sound" : : "Sound played when the water brush stops movwing."
	WaveHeight(string) : "Wave Height" : "3.0" : "No functionality. Wave height of the water material."

	input Open(void) : "Move the water brush to the end position (starting position + (move direction * move distance))."
	input Close(void) : "Move the water brush to the starting position."
	input SetPosition(string) : "Move the water brush to a specific position between 0.0 and 1.0, where 0 is the starting position and 1 is the starting position + (move direction * move distance)."

	output OnFullyOpen(void) : "Fired when the water brush reaches the end position (starting position + (move direction * move distance))."
	output OnFullyClosed(void) : "Fired when the water brush reaches the starting position."
]

@SolidClass base(BaseAnimatingBrush) = func_weight_button : 
    "A button which activates after a specified amount of weight is applied."
[
	WeightToActivate(float) 	: "Amount of weight required before this button activates, in KG."

	output OnPressed(void)		: "Fired when the button is touching enough weight."
	output OnReleased(void)		: "Fired when the button was pressed, but weight was removed."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_end") = game_end : 
	"An entity that ends a multiplayer game." 
[
	master(string) : "Master" : : "Half-Life legacy support: The name of a multisource entity. If the master hasn't been activated, this entity will not activate."
	input EndGame(void) : "End the multiplayer game."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_forcerespawn")  = game_forcerespawn :
	"Removes buildings, grenades, etc., from the world and forces all players to respawn, without being killed."
[
	input ForceRespawn(void) : "Force players to respawn and remove buildings, grenades, etc., from the world."
	input ForceRespawnSwitchTeams(void) : "Switch all players to the opposite team, and then respawn all players (and remove buildings, grenades, etc., from the world)."
	input ForceTeamRespawn(integer) : "Force players on a specific team to respawn. 2 for Red, 3 for Blue. This does NOT remove buildings, grenades, etc., from the world..."
	
	output OnForceRespawn(void) : "Sent when the entity respawns the players."	
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_gib_manager") = game_gib_manager : 
    "An entity to control the number of gibs in the world, for performance reasons." 
[
	maxpieces(integer)	: "Max Gib Count" : -1 : "Sets the max number of gib that can be spawned at a time. (-1=no limit)"
	maxpiecesdx8(integer)	: "Max Gib Count On DirectX 8" : -1 : "Sets the max number of gib that can be spawned at a time under DirectX 8. (-1 = use Max Gib Count setting)"
	allownewgibs(boolean)	: "Allow New Gibs To Spawn?" : 0 : "If true, when the max gib count is reached, oldest gibs are removed as new gibs spawn. If false, new gibs will not be spawned once the gib limit is reached."
	
	input SetMaxPieces(integer)	: "Set the max gib count."
	input SetMaxPiecesDX8(integer)	: "Set the max gib count under DirectX 8."
]

@PointClass base(BaseEntityPoint, TeamNum) studioprop("models/editor/camera.mdl") = game_intro_viewpoint :
	"Creates a camera from whose perspective you get images displayed as long as you have no team joined. With several game_intro_viewpoints, all appear for a certain time in turn. "
[	
	step_number(integer) : "Step Number. Intro starts at 1." : 1 : "The number of viewpoints in the series of all game_intro_viewpoints. These are displayed in sequence."
	time_delay(float) : "Time to spend here." : 12 : "The time that the image should be displayed before the next one comes."
	hint_message(string) : "Hint Message here." : "A message appears with the image."
	event_to_fire(string) : "Game Event to Fire"
	event_delay(float) : "Game Event fire Delay" : 3
	event_data_int(integer) : "Game Event Data" : 0
	fov(float) : "FOV" : 0 : "Maximum angle between the peripherals of the camera's vision."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_player_equip") = game_player_equip : 
	"An entity that gives equipment to the player who activates it. To use properly, add new keys to this entity, where each key is the classname of a weapon/item, and the corresponding value is the number of those weapons/items to give to the player who uses this entity. "+
	"If the 'Use Only' spawnflag isn't set, then players can just touch this entity to get the equipment. "+
	"Note: the Use input will cause a crash if the activator is NULL."+
	"Note: obj_sentrygun, obj_dispenser and obj_teleporter can be given to players with this entity, and possibly other entities such as projectiles."
[
	master(string) : "Team Master" : : "Half-Life legacy support: The name of a master entity. If the master hasn't been activated, this entity will not activate."	

	spawnflags(flags) =
	[
		1: "Use Only" : 0
	]
	
	input Use(void) : "Causes this entity to give the activating player weapons."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_player_team") = game_player_team : 
	"An entity that changes the team of the player who activates it. An alternative is firing SetTeam <team number> on the !activator."
[
	spawnflags(flags) =
	[
		1 : "Remove on Fire" : 0
		2 : "Kill Player" : 0
		4 : "Gib Player" : 0
	]
	
	// entity does not exist so this can't be used
	//target(string) : "game_team_master to use" 
	master(string) : "Master (Obsolete)" : : "Half-Life legacy support: The name of a master entity. If the master hasn't been activated, this entity will not activate."	
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_ragdoll_manager") = game_ragdoll_manager : 
	"An entity to control the number of ragdolls in the world, for performance reasons." 
[
	MaxRagdollCount(integer) : "Max Ragdoll Count" : -1 : "Sets the max number of ragdolls that can be in the world at a time (if they are flagged to fade). Set to -1 if you want to use the default value (g_ragdoll_maxcount)."
	MaxRagdollCountDX8(integer) : "Max Ragdoll Count DX8" : -1 : "Sets the max number of ragdolls that can be in the world at a time on DirectX 8 hardware (if they are flagged to fade). Set to -1 if you want to use the 'Max Ragdoll Count' value."

	SaveImportant(boolean) : "Save Important Ragdolls?" : 0 : "Should the ragdoll manager make sure ally ragdolls aren't deleted?"
	
	input SetMaxRagdollCount(integer) : "Set the Max Ragdoll Count."
	input SetMaxRagdollCountDX8(integer) : "Set the Max Ragdoll Count on DirectX 8 hardware."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_round_win") = game_round_win :
	 "Tells the game rules that the round has either been won (if a team is assigned) or enter Sudden Death mode (if no team is assigned)."
[	
	TeamNum(choices) : "Team" : 0 : "Team" =
	[
		0 : "None (Sudden Death)"
		2 : "2 - RED"
		3 : "3 - BLU"
		4 : "4 - Mercenary"
	]
	win_reason(string) : "Win Reason" : : "Displays the custom reason for a win on the HUD."	
	force_map_reset(boolean) : "Force Map Reset?" : 1 : "Force the map to reset during the force respawn after the round is over."
	
	switch_teams(boolean) : "Switch teams on map win?" : 0 : "Switch the teams when the game is going to be reset."
	
	input SetTeam(integer) : "Changes the entity's team (this is used to determine which team has won the round (0 = none)."
	input RoundWin(void) : "Tell the game rules the round is over."
	
	output OnRoundWin(void) : "Sent when the entity tells the game rules the round is over."	
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_score") = game_score : 
	"An entity that awards/deducts points from the player who activates it." 
[
	points(integer) : "Points to add (+/-)" : 1
	master(string) : "Master" : : "Half-Life legacy support: The name of a master entity. If the master hasn't been activated, this entity will not activate."
	
	spawnflags(flags) =
	[
		1: "Allow Negative" : 1
		2: "Team Points" : 0
	]

	input ApplyScore(void) : "Add score to player."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_text") = game_text : 
	"An entity that displays text on player's screens." 
[
	message(string) : "Message Text" :  : "Message to display onscreen. \n signifies a new line in the text. Note: Hammer automatically changes it to /n, therefore editing the VMF is needed. Can be changed with AddOutput."
	x(string) : "X (0 - 1.0 = left to right) (-1 centers)" : "-1" : "Horizontal position on the player's screens to draw the text. The value should be between 0 and 1, where 0 is the far left of the screen and 1 is the far right. -1 centers the text."
	y(string) : "Y (0 - 1.0 = top to bottom) (-1 centers)" : "-1" : "Vertical position on the player's screens to draw the text. The value should be between 0 and 1, where 0 is the top of the screen and 1 is the bottom. -1 centers the text."
	effect(Choices) : "Text Effect" : 0 =
	[
		0 : "Fade In/Out"
		1 : "Credits"
		2 : "Scan Out"
	]
	color(color255) : "Color1" : "100 100 100"
	color2(color255) : "Color2" : "240 110 0"
	fadein(string) : "Fade in Time (or character scan time)" : "1.5" : "The time it should take for the text to fully fade in."
	fadeout(string) : "Fade Out Time" : "0.5" : "The time it should take for the text to fade out, after the hold time has expired."
	holdtime(string) : "Hold Time" : "1.2" : "The time the text should stay onscreen, after fading in, before it begins to fade out."
	fxtime(string) : "Scan time (scan effect only)" : "0.25" : "If the 'Text Effect' is set to Scan Out, this is the time it should take to scan out all the letters in the text."
	channel(choices) : "Text Channel" : 1 : "You can have up to six individual game_text messages onscreen at once, stored in channels. Select which channel this text should be placed in, which will overwrite any active message already in that channel." =
	[
		0 : "Channel 0"
		1 : "Channel 1"
		2 : "Channel 2"
		3 : "Channel 3" 
		4 : "Channel 4"
		5 : "Channel 5"
	]
	master(string) : "Master" : : "Half-Life legacy support: The name of a master entity. If the master hasn't been activated, this entity will not activate."

	spawnflags(flags) =
	[
		1: "All Players" : 1
	]
	
	input Display(void) : "Display the message text."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_text_tf") = game_text_tf : 
	"An entity that displays text on player's screens, in pretty TF2 HUD format. This entity will not display when using the TF2 minimal HUD." 
[
	message(string) : "Message Text" :  : "Message to display onscreen."
	icon(string) : "HUD Icon" :  : "HUD icon (from mod_textures.res) to display."
	display_to_team(Choices) : "Audience" : 0 =
	[
		0 : "Everyone"
		2 : "RED Team Only"
		3 : "BLU Team Only"
	]
	background(Choices) : "Background Panel Color" : 0 =
	[
		0 : "Grey"
		2 : "Red"
		3 : "Blue"
	]

	input Display(void) : "Display the message text."
	input SetText(string) : "Set the text to display."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/game_ui") = game_ui : 
	"An entity used to override player input when the player is looking at it."
[
	spawnflags(flags) =
	[
		32 : "Freeze Player - Player cannot perform any actions freely" : 1
		64 : "Hide Weapon - Will put the player in reference pose" : 0
		128 : "+Use Deactivates" : 1
		256 : "Jump Deactivates" : 1
	]
	
	FieldOfView(float) : "Field Of View" : "-1.0" : "The amount of tolerance in the view checking when determining whether the player's input is still under control. 1.0 = straight ahead, 0.0 = +/- 90 degrees, -1.0 = all directions. If the player isn't within the tolerance, the player regains control."

	input Activate(string) : "Take control of the activating player."
	input Deactivate(void) : "Return control of the used player."

	output PlayerOn(void) : "Fired whenever this entity starts controlling the player's input."
	output PlayerOff(void) : "Fired whenever this entity stops controlling the player's input."
	output PressedMoveLeft(void) : "Fired whenever the player presses the moveleft key."
	output PressedMoveRight(void) : "Fired whenever the player presses the moveright key."
	output PressedForward(void) : "Fired whenever the player presses the forward key."
	output PressedBack(void) : "Fired whenever the player presses the backward key."
	output PressedAttack(void) : "Fired whenever the player presses the attack key."
	output PressedAttack2(void) : "Fired whenever the player presses the secondary attack key."

	output UnpressedMoveLeft(void) : "Fired whenever the player releases the moveleft key."
	output UnpressedMoveRight(void) : "Fired whenever the player releases the moveright key."
	output UnpressedForward(void) : "Fired whenever the player releases the forward key."
	output UnpressedBack(void) : "Fired whenever the player releases the backward key."
	output UnpressedAttack(void) : "Fired whenever the player releases the attack key."
	output UnpressedAttack2(void) : "Fired whenever the player releases the secondary attack key."

	output XAxis(string) : "An output that fires whenever the X axis of the player's input changes. i.e. -1 when the player has moveleft key down, 1 when the player has moveright key down, and 0 if neither."
	output YAxis(string) : "An output that fires whenever the Y axis of the player's input changes. i.e. -1 when the player has backward key down, 1 when the player has forward key down, and 0 if neither."
	output AttackAxis(string) : "An output that fires whenever the state of the player's attack key changes. i.e. 1 when the player has the attack key down, 0 otherwise."
	output Attack2Axis(string) : "An output that fires whenever the state of the player's secondary attack key changes. i.e. 1 when the player has the secondary attack key down, 0 otherwise."
]


@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_weapon_manager") = game_weapon_manager : 
	"An entity used to limit the number of a particular weapon type in the world. Useful in places where NPCs are spawning rapidly, dying, and dropping weapons." 
[
	weaponname(string) : "Weapon Classname" :  : "Classname of the weapon type to limit."
	maxpieces(integer) : "Max Allowed in Level"	: 0 : "The maximum amount of the specified weapon type allowed in the world."
	ammomod(float)	   : "Ammo modifier" : 1 : 	"Modifier for ammount of ammo dropped by a weapon."

	input SetAmmoModifier(float): "Adjust the ammo modifier."
]


@PointClass base(BaseEntity) iconsprite("editor-ficool2/game_weapon_manager") = game_weapon_manager : 
	"An entity used to limit the number of a particular weapon type in the world. Useful in places where NPCs are spawning rapidly, dying, and dropping weapons. Does not function in multiplayer." 
[
	weaponname(string) : "Weapon Classname" :  : "Classname of the weapon type to limit."
	maxpieces(integer) : "Max Allowed in Level"	: 0 : "The maximum amount of the specified weapon type allowed in the world."
	ammomod(float)	   : "Ammo modifier" : 1 : 	"Modifier for ammount of ammo dropped by a weapon."

	input SetAmmoModifier(float): "Adjust the ammo modifier."
	input SetMaxPieces(integer): "Set the maximum amount of the specified weapon type allowed."
]

@SolidClass base(BaseEntityBrush) = game_zone_player : 
	"An entity used to count the number of players within a zone."
[
	master(string) : "Master" : : "Half-Life legacy support: The name of a master entity. If the master hasn't been activated, this entity will not activate."

	input CountPlayersInZone(void) : "Count the number of players in the zone, and fire the corresponding outputs."

	output OnPlayerInZone(void) : "Fired whenever a count finds a player inside the zone, with the player as the activator."
	output OnPlayerOutZone(void) : "Fired whenever a count finds a player outside the zone, with the player as the activator."
	output PlayersInCount(integer) : "Fired after a count, and contains the number of players found inside the zone."
	output PlayersOutCount(integer) : "Fired after a count, and contains the number of players found outside the zone."
]

@PointClass base(env_shooter_base) iconsprite("editor-ficool2/gibshooter") = gibshooter : 
	"An entity that shoots out gibs. May not work correctly, use env_shooter instead. Style of body part depends on the language type."
[	
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/hammer_updateignorelist") = hammer_updateignorelist :
	"Specifies entities that are to be ignored by the hammer_update_safe_entities console command." + 
	"Enter the targetnames of entities that you want to exclude into the list of fields here. " +
	"Several of these may exist in a map."
[
	IgnoredName01(target_destination) : "Ignored Name 01" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName02(target_destination) : "Ignored Name 02" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName03(target_destination) : "Ignored Name 03" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName04(target_destination) : "Ignored Name 04" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName05(target_destination) : "Ignored Name 05" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName06(target_destination) : "Ignored Name 06" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName07(target_destination) : "Ignored Name 07" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName08(target_destination) : "Ignored Name 08" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName09(target_destination) : "Ignored Name 09" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName10(target_destination) : "Ignored Name 10" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName11(target_destination) : "Ignored Name 11" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName12(target_destination) : "Ignored Name 12" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName13(target_destination) : "Ignored Name 13" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName14(target_destination) : "Ignored Name 14" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName15(target_destination) : "Ignored Name 15" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
	IgnoredName16(target_destination) : "Ignored Name 16" :  : "Do not send this entity's information back to Hammer during hammer_update_safe_entities."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/info_camera_link") = info_camera_link :
	"An entity that can use point_cameras to render images for materials used by entities. "+
	"To author the material, use the special identifier _rt_Camera " +
	"for the $baseTexture (or whatever texture you want, like envmap, etc.) in the .vmt " +
	"then connect the 'target' field to the entity which uses that material, and the 'PointCamera' " +
	"field to the point_camera you want to have appear on that entity's material. Does not function in Team Fortress 2."
[
	target(target_destination) : "Target" : : "Entity whose material uses _rt_camera,"
	PointCamera(target_destination) : "Camera Name" : : "The name of a point_camera entity in the map that the material should be rendered from."
	
	input SetCamera(string) : "Set the camera to use. The parameter should be the name of a point_camera entity in the map."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/info_constraint_anchor") = info_constraint_anchor : 
	"An entity used to attach constraints to a local position on an entity. Usually constraints will attach to the center of mass of an object. "+
	"Attach the desired constraint to this entity, and then parent this entity to the entity you want the constraint to apply to."
[
	massScale(float) : "Mass Scale" : "1" : "Amount to scale the mass of this body in the constraint solver."
]

@PointClass base(BaseEntity) size( -16 -16 0, 16 16 4 ) color(255 128 255)= info_ladder_dismount : 
	"An entity to handle endpoints for multiple ladders that are too close to each other."
[
	target(target_destination) : "LadderName" : : "If multiple ladders are near multiple endpoints, use this to stop them from interfering with each other."
]

@PointClass base(BaseEntity, Angles) iconsprite("editor-ficool2/info_landmark") = info_landmark : 
	"An entity that acts as a landmark for transitions to another level. There should be a corresponding info_landmark entity in the next map. Entities will be transitioned to the next level relative to the info_landmark entities."
[
]

@PointClass iconsprite("editor-ficool2/info_lighting") = info_lighting : 
	"An interal entity that can be used to change the lighting origin of a prop_static, and no other purpose. Set the prop_static's Lighting Origin to point at this entity to "+
	"make the prop_static light as if it was at the info_lighting's origin. Good for prop_static entities that are embedded in world geometry (like rocks/windows/etc)."
[
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/info_lighting_relative") = info_lighting_relative : 
	"Deprecated by 'LightingOrigin' keyvalue and 'SetLightingOrigin' input for point entities, use those instead. An entity that allows a model to be lit from a different light origin without affecting the environment around the model. Great for lighting up trees with many lights or doing manual light correction."
[
	LightingLandmark(target_destination) : "Lighting Landmark" : : "Entity at which the reference origin is contained. If empty, the info_lighting_relative's origin will be used."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/info_mass_center") = info_mass_center :
	"An entity that overrides the mass center of the target physics prop, or func_physbox, by moving it to the info_mass_center's location. Removed on map spawn."
[
	target(target_destination) : "Target object" :   : "The entity whose mass center will be overridden."
]

@PointClass iconsprite("editor-ficool2/info_no_dynamic_shadow")  = info_no_dynamic_shadow : 
	"Use this entity to mark surfaces that shouldn't receive dynamic shadows. Useful to apply to walls and floors "+
	"where shadows are drawn improperly, giving away the location of enemies."
[
	sides(sidelist) : "Brush face(s)" : : "The brush face(s) which will not receive dynamic shadows."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/info_null") = info_null : 
	"An entity that's immediately removed on spawning. Useful as a spotlight target."
[
]

@PointClass base(BaseEntityPoint, TeamNum, EnableDisable) studioprop("models/editor/camera.mdl") = info_observer_point :
	"Marks a camera location for Team Fortress 2 players. Any spectating players (due to selecting the Spectator team or being unable to respawn at the time) have the ability to select this camera location to observe."
[
	associated_team_entity(target_destination) : "Associated Team Entity" :  : "An entity associated with this point that can be owned by a team (such as a flag or control point). Players will only be able to use this observer point if their team owns the associated team entity."
	
	defaultwelcome(boolean) : "Welcome Point?" : 0 :  "Set whether this camera is among the ones players may see when they first join the server. If no cameras have this set to 'No', the game will pick from all cameras that are not team-bound."

	fov(float) : "FOV" : 0 : "Specifies the field-of-view angle. Larger numbers allow the camera to see more of the playing field. Default is 70."
]

@PointClass size(-1 -1 0, 1 1 1) color(80 150 225) studioprop("models/editor/overlay_helper.mdl") sphere(fademindist) sphere(fademaxdist) overlay() = info_overlay : 
	"An entity that places an overlay on the world." 
[
	targetname(target_source) : "Name" : : "Name of the overlay. Used to access the overlay with an env_texturetoggle."
   angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."																																																						 
	material(material) : "Material" : : "The material to overlay."
	sides(sidelist) : "Brush faces" : : "Faces on which the overlay will be applied."
	RenderOrder(integer) : "Render Order" : 0 : "Higher values render after lower values (on top). This value can be 0-3."
	StartU(float) : "U Start" : "0.0" : "Texture coordinates for the image X-axis. This normally starts at zero (left) and goes to 1 (right). Adjust values to change position and scaling."
	EndU(float) : "U End" : "1.0" : "Texture coordinates for the image X-axis. This normally starts at zero (left) and goes to 1 (right). Adjust values to change position and scaling."
	StartV(float) : "V Start" : "0.0" : "Texture coordinates for the image Y-axis. This normally starts at zero (top) and goes to 1 (bottom). Adjust values to change position and scaling."
	EndV(float) : "V End" : "1.0" : "Texture coordinates for the image Y-axis. This normally starts at zero (top) and goes to 1 (bottom). Adjust values to change position and scaling."
	BasisOrigin(Vector) : "Overlay Basis Origin" : : "Offset of the surface from the position of the overlay entity."
	BasisU(Vector) : "Overlay Basis U" : : "Direction of the material's X-axis."
	BasisV(Vector) : "Overlay Basis V" : : "Direction of the material's Y-axis."
	BasisNormal(Vector) : "Overlay Basis Normal"
	uv0(vector) : "Overlay Point 1"
	uv1(vector) : "Overlay Point 2"
	uv2(vector) : "Overlay Point 3"
	uv3(vector) : "Overlay Point 4"
	fademindist(float) : "Start Fade Dist" : -1 : "Distance at which the overlay starts to fade (<0 = use fademaxdist)."
	fademaxdist(float) : "End Fade Dist" : 0 : "Maximum distance at which the overlay is visible (0 = don't fade out)."
]


@PointClass size(-1 -1 0, 1 1 1) color(80 150 225) studioprop("models/editor/overlay_helper.mdl") sidelist(sides) sidelist(sides2) overlay_transition() = info_overlay_transition : 
    "Overlay Transition. Creates a scrolling texture between a brush or displacement and a water brush, commonly used for a 'Wave' effect." 
[
	targetname(target_source) : "Name" : : "Name of the overlay. Used to access the overlay with an env_texturetoggle."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."																																																						 
	material(material) : "Material" : : "The material to overlay."
	sides(sidelist) : "Brush faces" : : "Brush faces on which the overlay will be applied."
	sides2(sidelist) : "Water faces" : : "Water Faces on which the overlay will be applied."
	LengthTexcoordStart(float) : "Texcoord Length Start" : "0.0"
	LengthTexcoordEnd(float) : "Texcoord Length End" : "1.0"
	WidthTexcoordStart(float) : "Texcoord Width Start" : "0.0"
	WidthTexcoordEnd(float) : "Texcoord Width End" : "1.0"
	Width1(float) : "Width Land" : "25.0"
	Width2(float) : "Width Water" : "25.0"
	DebugDraw(boolean) : "Force Draw? (Debug)" : 0 : "Force the overlay to draw for debugging."
]

@PointClass base(BaseEntityPoint) studioprop("models/editor-ficool2/cone_helper_blue.mdl") line(255 255 255, targetname, cpoint1) line(255 255 255, targetname, cpoint2) line(255 255 255, targetname, cpoint3) line(255 255 255, targetname, cpoint4) line(255 255 255, targetname, cpoint5) line(255 255 255, targetname, cpoint6) line(255 255 255, targetname, cpoint7) line(255 255 255, targetname, cpoint8) line(255 255 255, targetname, cpoint9) line(255 255 255, targetname, cpoint10) line(255 255 255, targetname, cpoint11) line(255 255 255, targetname, cpoint12) line(255 255 255, targetname, cpoint13) line(255 255 255, targetname, cpoint14) line(255 255 255, targetname, cpoint15) line(255 255 255, targetname, cpoint16) line(255 255 255, targetname, cpoint17) line(255 255 255, targetname, cpoint18) line(255 255 255, targetname, cpoint19) line(255 255 255, targetname, cpoint20) line(255 255 255, targetname, cpoint21) line(255 255 255, targetname, cpoint22) line(255 255 255, targetname, cpoint23) line(255 255 255, targetname, cpoint24) line(255 255 255, targetname, cpoint25) line(255 255 255, targetname, cpoint26) line(255 255 255, targetname, cpoint27) line(255 255 255, targetname, cpoint28) line(255 255 255, targetname, cpoint29) line(255 255 255, targetname, cpoint30) line(255 255 255, targetname, cpoint31) line(255 255 255, targetname, cpoint32) line(255 255 255, targetname, cpoint33) line(255 255 255, targetname, cpoint34) line(255 255 255, targetname, cpoint35) line(255 255 255, targetname, cpoint36) line(255 255 255, targetname, cpoint37) line(255 255 255, targetname, cpoint38) line(255 255 255, targetname, cpoint39) line(255 255 255, targetname, cpoint40) line(255 255 255, targetname, cpoint41) line(255 255 255, targetname, cpoint42) line(255 255 255, targetname, cpoint43) line(255 255 255, targetname, cpoint44) line(255 255 255, targetname, cpoint45) line(255 255 255, targetname, cpoint46) line(255 255 255, targetname, cpoint47) line(255 255 255, targetname, cpoint48) line(255 255 255, targetname, cpoint49) line(255 255 255, targetname, cpoint50) line(255 255 255, targetname, cpoint51) line(255 255 255, targetname, cpoint52) line(255 255 255, targetname, cpoint53) line(255 255 255, targetname, cpoint54) line(255 255 255, targetname, cpoint55) line(255 255 255, targetname, cpoint56) line(255 255 255, targetname, cpoint57) line(255 255 255, targetname, cpoint58) line(255 255 255, targetname, cpoint59) line(255 255 255, targetname, cpoint60) line(255 255 255, targetname, cpoint61) line(255 255 255, targetname, cpoint62) line(255 255 255, targetname, cpoint63) = info_particle_system : 
	"An entity that spawns a particle system built using the particle editor."
[
	effect_name(string) : "Particle System Name" : : "The name of the particle system to spawn. NOT the name of a PCF file!"
	
	start_active(boolean) : "Start Active?" : 0 : "Whether the particle system should begin as soon as the entity spawns."
	
	flag_as_weather(boolean) : "Flag as Weather?" : 0 : "Is this particle system going to be used as a weather effect? If so the particle system will not be rendered if the user has disabled weather effects."
	
	cpoint1(target_destination) : "Control Point 1" : : "If set, control point 1 of the effect will be at this entity's location."
	cpoint2(target_destination) : "Control Point 2" : : "If set, control point 2 of the effect will be at this entity's location. If control point 1 is not set, this will be ignored."
	cpoint3(target_destination) : "Control Point 3" : : "If set, control point 3 of the effect will be at this entity's location. If control point 2 is not set, this will be ignored."
	cpoint4(target_destination) : "Control Point 4" : : "If set, control point 4 of the effect will be at this entity's location. If control point 3 is not set, this will be ignored."
	cpoint5(target_destination) : "Control Point 5" : : "If set, control point 5 of the effect will be at this entity's location. If control point 4 is not set, this will be ignored."
	cpoint6(target_destination) : "Control Point 6" : : "If set, control point 6 of the effect will be at this entity's location. If control point 5 is not set, this will be ignored."
	cpoint7(target_destination) : "Control Point 7" : : "If set, control point 7 of the effect will be at this entity's location. If control point 6 is not set, this will be ignored."
	cpoint8(target_destination) : "Control Point 8" : : "If set, control point 8 of the effect will be at this entity's location. If control point 7 is not set, this will be ignored."
	cpoint9(target_destination) : "Control Point 9" : : "If set, control point 9 of the effect will be at this entity's location. If control point 8 is not set, this will be ignored."
	cpoint10(target_destination) : "Control Point 10" : : "If set, control point 10 of the effect will be at this entity's location. If control point 9 is not set, this will be ignored."
	cpoint11(target_destination) : "Control Point 11" : : "If set, control point 11 of the effect will be at this entity's location. If control point 10 is not set, this will be ignored."
	cpoint12(target_destination) : "Control Point 12" : : "If set, control point 12 of the effect will be at this entity's location. If control point 11 is not set, this will be ignored."
	cpoint13(target_destination) : "Control Point 13" : : "If set, control point 13 of the effect will be at this entity's location. If control point 12 is not set, this will be ignored."
	cpoint14(target_destination) : "Control Point 14" : : "If set, control point 14 of the effect will be at this entity's location. If control point 13 is not set, this will be ignored."
	cpoint15(target_destination) : "Control Point 15" : : "If set, control point 15 of the effect will be at this entity's location. If control point 14 is not set, this will be ignored."
	cpoint16(target_destination) : "Control Point 16" : : "If set, control point 16 of the effect will be at this entity's location. If control point 15 is not set, this will be ignored."
	cpoint17(target_destination) : "Control Point 17" : : "If set, control point 17 of the effect will be at this entity's location. If control point 16 is not set, this will be ignored."
	cpoint18(target_destination) : "Control Point 18" : : "If set, control point 18 of the effect will be at this entity's location. If control point 17 is not set, this will be ignored."
	cpoint19(target_destination) : "Control Point 19" : : "If set, control point 19 of the effect will be at this entity's location. If control point 18 is not set, this will be ignored."
	cpoint20(target_destination) : "Control Point 20" : : "If set, control point 20 of the effect will be at this entity's location. If control point 19 is not set, this will be ignored."
	cpoint21(target_destination) : "Control Point 21" : : "If set, control point 21 of the effect will be at this entity's location. If control point 10 is not set, this will be ignored."
	cpoint22(target_destination) : "Control Point 22" : : "If set, control point 22 of the effect will be at this entity's location. If control point 21 is not set, this will be ignored."
	cpoint23(target_destination) : "Control Point 23" : : "If set, control point 23 of the effect will be at this entity's location. If control point 22 is not set, this will be ignored."
	cpoint24(target_destination) : "Control Point 24" : : "If set, control point 24 of the effect will be at this entity's location. If control point 23 is not set, this will be ignored."
	cpoint25(target_destination) : "Control Point 25" : : "If set, control point 25 of the effect will be at this entity's location. If control point 24 is not set, this will be ignored."
	cpoint26(target_destination) : "Control Point 26" : : "If set, control point 26 of the effect will be at this entity's location. If control point 25 is not set, this will be ignored."
	cpoint27(target_destination) : "Control Point 27" : : "If set, control point 27 of the effect will be at this entity's location. If control point 26 is not set, this will be ignored."
	cpoint28(target_destination) : "Control Point 28" : : "If set, control point 28 of the effect will be at this entity's location. If control point 27 is not set, this will be ignored."
	cpoint29(target_destination) : "Control Point 29" : : "If set, control point 29 of the effect will be at this entity's location. If control point 28 is not set, this will be ignored."
	cpoint30(target_destination) : "Control Point 30" : : "If set, control point 30 of the effect will be at this entity's location. If control point 29 is not set, this will be ignored."
	cpoint31(target_destination) : "Control Point 31" : : "If set, control point 31 of the effect will be at this entity's location. If control point 30 is not set, this will be ignored."
	cpoint32(target_destination) : "Control Point 32" : : "If set, control point 32 of the effect will be at this entity's location. If control point 31 is not set, this will be ignored."
	cpoint33(target_destination) : "Control Point 33" : : "If set, control point 33 of the effect will be at this entity's location. If control point 32 is not set, this will be ignored."
	cpoint34(target_destination) : "Control Point 34" : : "If set, control point 34 of the effect will be at this entity's location. If control point 33 is not set, this will be ignored."
	cpoint35(target_destination) : "Control Point 35" : : "If set, control point 35 of the effect will be at this entity's location. If control point 34 is not set, this will be ignored."
	cpoint36(target_destination) : "Control Point 36" : : "If set, control point 36 of the effect will be at this entity's location. If control point 35 is not set, this will be ignored."
	cpoint37(target_destination) : "Control Point 37" : : "If set, control point 37 of the effect will be at this entity's location. If control point 36 is not set, this will be ignored."
	cpoint38(target_destination) : "Control Point 38" : : "If set, control point 38 of the effect will be at this entity's location. If control point 37 is not set, this will be ignored."
	cpoint39(target_destination) : "Control Point 39" : : "If set, control point 39 of the effect will be at this entity's location. If control point 38 is not set, this will be ignored."
	cpoint40(target_destination) : "Control Point 40" : : "If set, control point 40 of the effect will be at this entity's location. If control point 39 is not set, this will be ignored."
	cpoint41(target_destination) : "Control Point 41" : : "If set, control point 41 of the effect will be at this entity's location. If control point 40 is not set, this will be ignored."
	cpoint42(target_destination) : "Control Point 42" : : "If set, control point 42 of the effect will be at this entity's location. If control point 41 is not set, this will be ignored."
	cpoint43(target_destination) : "Control Point 43" : : "If set, control point 43 of the effect will be at this entity's location. If control point 42 is not set, this will be ignored."
	cpoint44(target_destination) : "Control Point 44" : : "If set, control point 44 of the effect will be at this entity's location. If control point 43 is not set, this will be ignored."
	cpoint45(target_destination) : "Control Point 45" : : "If set, control point 45 of the effect will be at this entity's location. If control point 44 is not set, this will be ignored."
	cpoint46(target_destination) : "Control Point 46" : : "If set, control point 46 of the effect will be at this entity's location. If control point 45 is not set, this will be ignored."
	cpoint47(target_destination) : "Control Point 47" : : "If set, control point 47 of the effect will be at this entity's location. If control point 46 is not set, this will be ignored."
	cpoint48(target_destination) : "Control Point 48" : : "If set, control point 48 of the effect will be at this entity's location. If control point 47 is not set, this will be ignored."
	cpoint49(target_destination) : "Control Point 49" : : "If set, control point 49 of the effect will be at this entity's location. If control point 48 is not set, this will be ignored."
	cpoint50(target_destination) : "Control Point 50" : : "If set, control point 50 of the effect will be at this entity's location. If control point 49 is not set, this will be ignored."
	cpoint51(target_destination) : "Control Point 51" : : "If set, control point 51 of the effect will be at this entity's location. If control point 50 is not set, this will be ignored."
	cpoint52(target_destination) : "Control Point 52" : : "If set, control point 52 of the effect will be at this entity's location. If control point 51 is not set, this will be ignored."
	cpoint53(target_destination) : "Control Point 53" : : "If set, control point 53 of the effect will be at this entity's location. If control point 52 is not set, this will be ignored."
	cpoint54(target_destination) : "Control Point 54" : : "If set, control point 54 of the effect will be at this entity's location. If control point 53 is not set, this will be ignored."
	cpoint55(target_destination) : "Control Point 55" : : "If set, control point 55 of the effect will be at this entity's location. If control point 54 is not set, this will be ignored."
	cpoint56(target_destination) : "Control Point 56" : : "If set, control point 56 of the effect will be at this entity's location. If control point 55 is not set, this will be ignored."
	cpoint57(target_destination) : "Control Point 57" : : "If set, control point 57 of the effect will be at this entity's location. If control point 56 is not set, this will be ignored."
	cpoint58(target_destination) : "Control Point 58" : : "If set, control point 58 of the effect will be at this entity's location. If control point 57 is not set, this will be ignored."
	cpoint59(target_destination) : "Control Point 59" : : "If set, control point 59 of the effect will be at this entity's location. If control point 58 is not set, this will be ignored."
	cpoint60(target_destination) : "Control Point 60" : : "If set, control point 60 of the effect will be at this entity's location. If control point 59 is not set, this will be ignored."
	cpoint61(target_destination) : "Control Point 61" : : "If set, control point 61 of the effect will be at this entity's location. If control point 60 is not set, this will be ignored."
	cpoint62(target_destination) : "Control Point 62" : : "If set, control point 62 of the effect will be at this entity's location. If control point 61 is not set, this will be ignored."
	cpoint63(target_destination) : "Control Point 63" : : "If set, control point 63 of the effect will be at this entity's location. If control point 62 is not set, this will be ignored."
	
	cpoint1_parent(integer) : "Control Point 1's Parent" : 0 : "If set and nonzero, control point 1 of the effect will use this point for its parent."
	cpoint2_parent(integer) : "Control Point 2's Parent" : 0 : "If set and nonzero, control point 2 of the effect will use this point for its parent."
	cpoint3_parent(integer) : "Control Point 3's Parent" : 0 : "If set and nonzero, control point 3 of the effect will use this point for its parent."
	cpoint4_parent(integer) : "Control Point 4's Parent" : 0 : "If set and nonzero, control point 4 of the effect will use this point for its parent."
	cpoint5_parent(integer) : "Control Point 5's Parent" : 0 : "If set and nonzero, control point 5 of the effect will use this point for its parent."
	cpoint6_parent(integer) : "Control Point 6's Parent" : 0 : "If set and nonzero, control point 6 of the effect will use this point for its parent."
	cpoint7_parent(integer) : "Control Point 7's Parent" : 0 : "If set and nonzero, control point 7 of the effect will use this point for its parent."

	input Start(void) : "Tell the particle system to start emitting."
	input Stop(void) : "Tell the particle system to stop emitting."
]

@PointClass base(BaseEntityPoint) studio("models/editor/playerstart.mdl") = info_player_deathmatch :
	"This entity marks the spawn point for Half Life 2 deathmatch players. Backwards compatibility only."
[
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/playerstart.mdl") = info_player_start :
	"This entity indicates the position and facing direction at which the player will spawn."
[
	spawnflags(flags) =
	[
		1: "Master (Has priority if multiple info_player_starts exist)" : 0
	]
]

@PointClass base(BaseEntityPoint,TeamNum,EnableDisable) studioprop("models/editor-abs/dev_engy.mdl") = info_player_teamspawn :
	"This entity marks the spawn point for Team Fortress 2 players."
[
    controlpoint(target_destination) : "Associated Control Point" : : "The team_control_point associated with this spawn. Ownership of control points will control this spawn point's enabled state."
	
	TeamNum(choices) : "Team" : 0 : "IMPORTANT: If you have ANY team_control_point_round entities in your map, you MUST also set the '<team> spawn for round' settings below. If this is not done both teams will spawn at all spawn points." =
	[
		0 : "Any"
		2 : "Red"
		3 : "Blue"
		4 : "Mercenary"
	]
	SpawnMode(choices) : "Spawn Mode" : 0 : "How the game decides when a player can spawn here.  Triggered mode will only allow players sent via a trigger_player_respawn_override (in which case this spawn must be named, and match the trigger)." =
	[
		0 : "Normal"
		1 : "Triggered"
	] 
	round_bluespawn(target_destination) : "Blue spawn for round" : : "Blue spawn point when the associated round is being played."
	round_redspawn(target_destination) : "Red spawn for round" : : "Red spawn point when the associated round is being played."
	
	spawnflags(flags) =
	[
		1 :	   "Scout" : 1
		2 :    "Sniper" : 1
		4 :    "Soldier" : 1
		8 :    "Demoman" : 1
		16 :   "Medic" : 1
		32 :   "Heavyweapons" : 1
		64 :   "Pyro" : 1
		128 :  "Spy" : 1
		256 :  "Engineer" : 1
		//512 :  "Mercenary" : 1
		1024 :  "Civilian" : 1
		2048 :  "Juggernaut" : 1
	]
]

@PointClass base(BaseEntityPoint) decal() studioprop("models/editor/axis_helper_thick.mdl") = info_projecteddecal : 
	"An entity that projects a decal onto the world (or props). If the decal has no target name, it will immediately apply itself when "+
	"the level is loaded. If it has a name specified, it won't apply until it receives the 'Activate' input and will count towards the edict limit."
[
	texture(decal) : "Texture" : : "The image to apply as a decal."
	Distance(float) : "Distance" : 64 : "Distance from the origin to project the decal."

	input Activate(void) : "Force the decal to apply itself to the world."
]

@PointClass sphere(radius) base(BaseEntityPoint) iconsprite("editor-ficool2/info_radial_link_controller") = info_radial_link_controller :
	"This entity automatically severs node connections that pass through its radius. If it moves, it will restore those connections."
[
	radius(float) : "Radius" : 120 : "Range at which node connections will be affected."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/info_target")  = info_target : 
	"An entity that does nothing and simply exists. Very useful as a positioning entity for other entities to refer to (i.e. the endpoint of an env_beam)"
[
	spawnflags( Flags ) =
	[
		1 : "Transmit to client (respect PVS)" : 0
	]
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/playerstart.mdl") = info_teleport_destination : 
	"Same function as info_target, although easier to position for entities requiring a human-sized target, such as teleporters."
[
]

@PointClass base(BaseEntityPoint) decal() studioprop("models/editor/axis_helper_thick.mdl") = infodecal : 
	"An entity that places a decal on the world. If the decal has no target name, it will immediately apply itself when the level is loaded. "+
	"If it has a name specified, it won't apply until it receives the 'Activate' input and will count towards the edict limit."
[
	texture(decal) : "Texture" : : "The image to apply as a decal."

	LowPriority(boolean) : "Low Priority (can be replaced)?" : 0

	input Activate(void) : "Force the decal to apply itself to the world."
]																																	

@PointClass base(Item) studioprop() = item_ammopack_full :	
     "Full ammo pack for players." 
[
	model(studio) : "Model" : "models/items/ammopack_large.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "AmmoPack.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_ammopack_medium : 
     "Medium ammo pack for players."
[
	model(studio) : "Model" : "models/items/ammopack_medium.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "AmmoPack.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_ammopack_small : 
     "Small ammo pack for players."
[
	model(studio) : "Model" : "models/items/ammopack_small.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "AmmoPack.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_healthkit_mega : 
    "Mega health kit for players (100 HP overheal)." 
[
	model(studio) : "Model" : "models/pickups/megahealth.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "HealthkitMega.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_healthkit_full : 
    "Full health kit for players." 
[
	model(studio) : "Model" : "models/items/medkit_large.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "Healthkit.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_healthkit_medium :
    "Medium health kit for players." 
[
	model(studio) : "Model" : "models/items/medkit_medium.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "Healthkit.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_healthkit_small :	
    "Small health kit for players." 
[
	model(studio) : "Model" : "models/items/medkit_small.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "Healthkit.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(Item) studioprop() = item_healthkit_tiny :	
    "Overheal health kit for players." 
[
	model(studio) : "Model" : "models/items/medkit_overheal.mdl" : "The model this entity should appear as. 128-character limit."
	pickup_sound(sound): "Pickup Sound" : "HealthKitTiny.Touch" : "Sound to play when picking up ammo."
]

@PointClass base(BaseAnimating) studioprop("models/can.mdl") = item_sodacan : 
	"Half-Life legacy: A beverage created from a Beverage Dispenser (env_beverage). Uses models/can.mdl by default, you will need to provide your own as it is missing."
[
]

// item_teamflag uses prop_dynamic base in code??
@PointClass base(prop_dynamic_base, TeamNum, EnableDisable) studioprop() = item_teamflag :
    "Team Fortress 2 flag entity."
[
	model(studio) : "Model" : "models/flag/briefcase.mdl" : "The model this entity should appear as. 128-character limit."
	ReturnTime(float) : "Return time (in seconds)" : 60 : "Length of time (in seconds) before dropped flag/intelligence returns to base."
	NeutralTime(float) : "Neutral time (in seconds)" : 60 : "Length of time (in seconds) before neutral dropped flag/intelligence returns to base."
	
	GameType(choices) : "Game Type" : 0 : "Type of game this flag will be used for." =
	[
		0 : "CTF"
		1 : "Attack/Defend"
		2 : "Territory Control"
		3 : "Invade"
		4 : "Resource Control"
	]

	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
	
	output OnReturn(void)  : "Sent when the flag is returned via timer."
	output OnPickup(void)  : "Sent when the flag is picked up."
	output OnDrop(void)    : "Sent when the flag is dropped."
	output OnCapture(void) : "Sent when the flag is captured."
]

// ------------------------------------------------------------------------------------------------------------------
// Hardcoded rope base classes, thanks Valve!!
// These are directly copied from base.fgd, for some reason *any* changes cause rope rendering to break
// ------------------------------------------------------------------------------------------------------------------

@BaseClass = Targetname 
[ 
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."
	
	input Kill(void) : "Removes this entity from the world."
	input KillHierarchy(void) : "Removes this entity and all its children from the world."
	input AddOutput(string) : "Adds an entity I/O connection to this entity. Format: <output name> <targetname>:<inputname>:<parameter>:<delay>:<max times to fire (-1 == infinite)>. Very dangerous, use with care."
	input FireUser1(void) : "Causes this entity's OnUser1 output to be fired."
	input FireUser2(void) : "Causes this entity's OnUser2 output to be fired."
	input FireUser3(void) : "Causes this entity's OnUser3 output to be fired."
	input FireUser4(void) : "Causes this entity's OnUser4 output to be fired."
	
	output OnUser1(void) : "Fired in response to FireUser1 input."
	output OnUser2(void) : "Fired in response to FireUser2 input."
	output OnUser3(void) : "Fired in response to FireUser3 input."
	output OnUser4(void) : "Fired in response to FireUser4 input."
]

@BaseClass = Parentname
[ 
	parentname(target_destination) : "Parent" : : "The name of this entity's parent in the movement hierarchy. Entities with parents move with their parent."

	input SetParent(string) : "Changes the entity's parent in the movement hierarchy."
	input SetParentAttachment(string) : "Change this entity to attach to a specific attachment point on its parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment."
	input SetParentAttachmentMaintainOffset(string) : "Change this entity to attach to a specific attachment point on it's parent. Entities must be parented before being sent this input. The parameter passed in should be the name of the attachment. The entity will maintain it's position relative to the parent at the time it is attached."
	input ClearParent(void) : "Removes this entity from the the movement hierarchy, leaving it free to move independently."
]

@BaseClass = DXLevelChoice
[ 
	mindxlevel(choices) : "Minimum DX Level" : 0 = 
	[
		0 : "default (lowest)"
		70 : "dx7"
		80 : "dx8.0 (4600Ti)"
		81 : "dx8.1 (FX5200)"
		90 : "dx9 SM2.0"
		95 : "dx9 SM3.0"
	]
	maxdxlevel(choices) : "Maximum DX Level" : 0 = 
	[
		0 : "default (highest)"
		60 : "dx6"
		70 : "dx7"
		80 : "dx8.0 (4600Ti)"
		81 : "dx8.1 (FX5200)"
		90 : "dx9 SM2.0"
		95 : "dx9 SM3.0"
	]
]

@BaseClass = KeyFrame
[
	NextKey(target_destination) : "Next KeyFrame" : : "Name of the next keyframe along this keyframe path."
	
	MoveSpeed(integer) : "Speed (units per second)" : 64
]

@BaseClass base(DXLevelChoice) = RopeKeyFrame
[
	spawnflags(Flags) = 
	[
		1 :  "Auto Resize" : 0
	]

	Slack(integer) : "Slack" : 25 : "How much extra length the rope has (by default it has the length between its two endpoints in the editor)."

	Type(choices) : "Type" : 0 =
	[
		0  : "Rope"
		1  : "Semi-rigid"
		2  : "Rigid"
	]

	Subdiv(integer) : "Subdivision" : 2 : "Number of subdivisions between each rope segment. Maximum value is 8. Higher values make smoother ropes, but are slower to render."

	Barbed(boolean) : "Barbed" : 0 : "Test effect that makes the rope look sharper and more barbed."
	
	Width(string) : "Width (1-64)" : "2" : "Width of the rope."

	TextureScale(string) : "Texture Scale" : "1" : "This changes the texture resolution. The default resolution is 4 pixels per inch. Larger values stretch the texture and smaller values scrunch it up."
	
	Collide(boolean) : "Collide with world" : 0
	
	Dangling(boolean) : "Start Dangling" : 0 : "When set to Yes, the rope starts out detached from its target endpoint." 

	Breakable(boolean) : "Breakable" : 0 : "When set to yes, the rope can be detached from either endpoint when shot."

	RopeMaterial(material) : "Rope Material" : "cable/cable.vmt" : "The material to use when rendering the rope."

	input SetScrollSpeed(float) : "Set the speed at which the texture scrolls."
	input SetForce(string) : "Apply a force instantaneously to the rope. The parameter should be a vector containing the force to be applied (X Y Z)."
	input Break(void) : "Break the rope, if it's marked to do so."

	NoWind(boolean) : "Disable Wind" : 0 : "When set to Yes, the rope will no longer act as though it's being affected by wind."

]

@KeyFrameClass base(Targetname, Parentname, KeyFrame, RopeKeyFrame) studio("models/editor/axis_helper_thick.mdl") keyframe() = keyframe_rope : 
	"A node entity that marks a point in a rope. The first node in the rope should be a move_rope, followed by 1 or more keyframe_ropes."
[
]

@MoveClass base(Targetname, Parentname, KeyFrame, RopeKeyFrame) studio("models/editor/axis_helper.mdl") animator() = move_rope : 
	"The first node in set of nodes that are used to place ropes in the world. It should connect to 1 or more keyframe_rope entities."
[
	PositionInterpolator(choices) : "Position Interpolator" : 2 : "Curve Type. Currently only type 2 (Rope) is fully supported." =
	[
		0 : "Linear"
		1 : "Catmull-Rom Spline"
		2 : "Rope"
	]
]

// ------------------------------------------------------------------------------------------------------------------
// End of hardcoded base classes
// ------------------------------------------------------------------------------------------------------------------

@PointClass light() iconsprite("editor-ficool2/light") base(BaseEntity) sphere(_fifty_percent_distance) sphere(_zero_percent_distance) sphere(_distance) = light :
	"An invisible omnidirectional lightsource."
[
	_light(color255) : "Brightness" : "255 255 255 200" : "The RGB color and brightness of the light. Colors must be between 0 and 255; brightness can be anything."
	_lightHDR(color255) : "BrightnessHDR" : "-1 -1 -1 1" : "Brightness override used in HDR mode. Default is -1 -1 -1 1, which means no change."
	_lightscaleHDR(float) : "BrightnessScaleHDR" : "1" : "Amount to scale the light by when compiling for HDR."
	defaultstyle(Choices) : "Default Appearance" : 0 : "Default Custom Appearance to use, may not function." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	style(Choices) : "Appearance" : 0 : "Various Custom Appearance presets." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	pattern(string) : "Custom Appearance" :  : "A string of characters, like a sequence of piano keys, that define a pattern of brightness. a is dark and z is full intensity. Applies only to lights with a targetname."
	_constant_attn(string)	: "Constant" : "0" : "Determines brightness of the light at a certain distance.  Higher Constants dim the light near the entity."
	_linear_attn(string)	: "Linear" : "0" : "Determines brightness of the light at a certain distance.  Higher Linears dim the light at all distances."
	_quadratic_attn(string)	: "Quadratic" : "1" : "Determines brightness of the light at a certain distance.  Higher Quadratics dim the light far from the entity."
	_fifty_percent_distance(float) : "Half (50%) Falloff" : : "Distance from this light at which it is reduced to 50% brightness.  Ignores Quadratic, Linear, and Constant if used."
	_zero_percent_distance(float) : "Complete (0%) Falloff" : : "Distance from this light at which it cannot light objects anymore ((1/256)% brightness).  Requires Half Falloff."
	_hardfalloff(integer) : "Hard falloff" : 0 : "If set, causes lights to fall to exactly zero beyond the zero percent distance. May cause unrealistic lighting if not used carefully."
	_distance(integer) : "Maximum Distance" : 0 : "This is the distance that light is allowed to cast, in units."
	
	spawnflags(Flags) =
	[ 
	     1 : "Initially dark - only works when light has a targetname." : 0
	]
	
	input TurnOn(void) : "Turn the light on."
	input TurnOff(void) : "The the light off."
	input Toggle(void) : "Toggle the light's current state."
	input SetPattern(string) : "Set a custom pattern of light brightness for this light. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."
	input FadeToPattern(string) : "Fades from first value in old pattern, to first value in the new given pattern. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/light_directional") = light_directional : 
	"A directional light with no falloff. Similar to sunlight in light_environment."
[
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."
	pitch(integer) : "Pitch" : 0 : "The downward pitch of the direct light from the entity. 0 is horizontal, -90 is straight down."
	_light(color255) : "Brightness" : "255 255 255 200" : "Color and brightness of direct light under LDR lighting."
	_lightHDR(color255) : "BrightnessHDR" : "-1 -1 -1 1" : "Color and brightness of direct light under HDR lighting."
	_lightscaleHDR(float) : "BrightnessScaleHDR" : "0.7" : "Amount to scale the light by when compiling for HDR lighting."
	SunSpreadAngle(float) : "SpreadAngle" : 0 : "The angular extent of the light for casting soft shadows. Higher numbers are more diffuse. 1 is a good starting value."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/light_dynamic") sphere(distance) lightcone() = light_dynamic : 
	"An invisible lightsource that changes in some way over time." 
[
	target(target_destination) : "Entity to point at" : : "The name of an entity in the map that the dynamic light will point at."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."																																																						 
	_light(color255) : "Light color" : "255 255 255 200" : "The RGB render color of the spotlight. Colors must be between 0 and 255."
	brightness(integer) : "Light brightness" : 0 : "The intensity of the spotlight."
	_inner_cone(integer) : "Inner (bright) angle" : 30 : "The angles of the inner spotlight beam. 0 makes it omnidirectional."
	_cone(integer) : "Outer (fading) angle" : 45 : "The angles of the outer spotlight beam. 0 makes it omnidirectional."
	pitch(integer) : "Pitch" : -90 : "Used instead of Pitch Yaw Roll's value for reasons unknown."
	distance(float) : "Maximum distance" : 120 : "This is the distance that light is allowed to cast, in units."
	spotlight_radius(float) : "Spotlight end radius" : 80 : "This is the radius of the light, in units, at the object that it is hitting."
	style(Choices) : "Appearance" : 0 : "Various Custom Appearance presets." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	input Color(color255) : "Set the light's render color (R G B)."
	input brightness(integer) : "Set the light brightness."
	input distance(float) : "Set the maximum light distance."
	input _inner_cone(integer) : "Set the inner (bright) angle."
	input _cone(integer) : "Set the outer (fading) angle."
	input spotlight_radius(float) : "Set the radius of the spotlight at the end point."
	input style(integer) : "Change the lightstyle (see Appearance field for possible values)."

	spawnflags(Flags) = 
	[ 
		1 : "Do not light world (better performance)" : 0 
		2 : "Do not light models (better performance)" : 0
		4 : "Add Displacement Alpha" : 0
		8 : "Subtract Displacement Alpha" : 0
	]
	
	input TurnOn(void) : "Turn the light off."
	input TurnOff(void) : "Turn the light on."
	input Toggle(void) : "Toggle the light on/off."
]


@PointClass base(BaseEntity) iconsprite("editor-ficool2/light_environment") = light_environment : 
	"Sets the color and angle of the light from the sun and sky. The light_environment can be named.toggled, although the quality will be noticeably worse as bounced lighting will not be simulated on a named light."
[
	pitch(integer) : "Pitch" : 0 : "The downward pitch of the light from the sun. 0 is horizontal, -90 is straight down."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."																																																						 
	_light(color255) : "Brightness" : "255 255 255 200" : "Color and brightness of direct Sunlight."
	_ambient(color255) : "Ambient" : "255 255 255 20" : "Color and brightness of diffuse Skylight."
	_lightHDR(color255) : "BrightnessHDR" : "-1 -1 -1 1" : "Override for Brightness when compiling HDR lighting. Defaults to -1 -1 -1 1, which means the same as LDR."
	_lightscaleHDR(float) : "BrightnessScaleHDR" : "1" : "Amount to scale the direct light by when compiling for HDR."
	_ambientHDR(color255) : "AmbientHDR" : "-1 -1 -1 1" : "Override for Ambient when compiling HDR lighting. Defaults to -1 -1 -1 1, which means the same as LDR."
	_AmbientScaleHDR(float) : "AmbientScaleHDR" : "1" : "Amount to scale the ambient light by when compiling for HDR."
	SunSpreadAngle(float) : "SunSpreadAngle" : 0 : "The angular extent of the sun for casting soft shadows. Higher numbers are more diffuse. 2 is a good starting value."
	defaultstyle(Choices) : "Default Appearance" : 0 : "Default Custom Appearance to use, may not function." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	style(Choices) : "Appearance" : 0 : "Various Custom Appearance presets." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	pattern(string) : "Custom Appearance" :  : "Set a custom pattern of light brightness for this light. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."

	spawnflags(Flags) =
	[ 
	     1 : "Initially dark - only works when light has a targetname." : 0
	]
	
	input TurnOn(void) : "Turn the light on."
	input TurnOff(void) : "The the light off."
	input Toggle(void) : "Toggle the light's current state."
	input SetPattern(string) : "Set a custom pattern of light brightness for this light. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."
	input FadeToPattern(string) : "Fades from first value in old pattern, to first value in the new given pattern. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."
]

// copyed from light_spot, not worth to use an independant base

@PointClass base(BaseEntity) lightprop("models/editor/spot.mdl") lightcone() sphere(_fifty_percent_distance) sphere(_zero_percent_distance) sphere(_distance) = light_spot :
	"An invisible and directional spotlight."
[
	target(target_destination) : "Entity to point at" : : "The name of an entity in the map that the spotlight will point at. This will override the spotlight's angles."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."																																																						 
	_light(color255) : "Brightness" : "255 255 255 200" : "The RGB color and brightness of the light. Colors must be between 0 and 255; brightness can be anything."
	_lightHDR(color255) : "BrightnessHDR" : "-1 -1 -1 1" : "Brightness override used in HDR mode. Default is -1 -1 -1 1, which means no change."
	_lightscaleHDR(float) : "BrightnessScaleHDR" : "1" : "Amount to scale the light by when compiling for HDR."
	defaultstyle(Choices) : "Default Appearance" : 0 : "Default Custom Appearance to use, May not function." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	style(Choices) : "Appearance" : 0 : "Various Custom Appearance presets." =
	[
		0 : "Normal"
		1 : "Flicker A"
		2 : "Slow, strong pulse"
		3 : "Candle A"
		4 : "Fast strobe"
		5 : "Gentle pulse"
		6 : "Flicker B"
		7 : "Candle B"
		8 : "Candle C"
		9 : "Slow strobe"
		10: "Fluorescent flicker"
		11: "Slow pulse, noblack"
		12: "Underwater light mutation"
	]
	pattern(string) : "Custom Appearance" :  : "A string of characters, like a sequence of piano keys, that define a pattern of brightness. a is dark and z is full intensity. Applies only to lights with a targetname."
	_constant_attn(string)	: "Constant" : "0" : "Determines brightness of the light at a certain distance.  Higher Constants dim the light near the entity."
	_linear_attn(string)	: "Linear" : "0" : "Determines brightness of the light at a certain distance.  Higher Linears dim the light at all distances."
	_quadratic_attn(string)	: "Quadratic" : "1" : "Determines brightness of the light at a certain distance.  Higher Quadratics dim the light far from the entity."
	_fifty_percent_distance(float) : "Half (50%) Falloff" : : "Distance from this light at which it is reduced to 50% brightness.  Ignores Quadratic, Linear, and Constant if used."
	_zero_percent_distance(float) : "Complete (0%) Falloff" : : "Distance from this light at which it cannot light objects anymore ((1/256)% brightness).  Requires Half Falloff."
	_hardfalloff(integer) : "Hard falloff" : 0 : "If set, causes lights to fall to exactly zero beyond the zero percent distance. May cause unrealistic lighting if not used carefully."
	
	_inner_cone(integer) : "Inner (bright) angle" : 30 : "The angles of the inner spotlight beam."
	_cone(integer) : "Outer (fading) angle" : 45 : "The angles of the outer spotlight beam."
	_exponent(integer) : "Focus" : 1 : "Changes the distance between the umbra and penumbra cone - higher values make the edge of the light more blurred,"
	_distance(integer) : "Maximum distance" : 0 : "This is the distance that light is allowed to cast, in units."
	pitch(angle_negative_pitch) : "Pitch" : -90 : "Used instead of Pitch Yaw Roll's value for reasons unknown."
	
	spawnflags(Flags) =
	[ 
	     1 : "Initially dark - only works when light has a targetname." : 0
	]
	
	input TurnOn(void) : "Turn the light on."
	input TurnOff(void) : "The the light off."
	input Toggle(void) : "Toggle the light's current state."
	input SetPattern(string) : "Set a custom pattern of light brightness for this light. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."
	input FadeToPattern(string) : "Fades from first value in old pattern, to first value in the new given pattern. Pattern format is a string of characters, where 'a' is total darkness, 'z' fully bright. i.e. 'aaggnnttzz' would be a steppy fade in from dark to light."
]


@PointClass base(BaseEntity) iconsprite("editor/logic_auto") = logic_auto : 
	"Fires outputs when a map spawns. " +
	"If 'Remove on fire' flag is set the logic_auto is deleted after firing. " +
	"It can be set to check a global state before firing. This allows you to only fire events based on "+
	"what took place in a previous map."
[
	globalstate(choices) : "Global State to Read" : "" : "If set, this specifies a global state to check before firing. The OnMapSpawn output will only fire if the global state is set." =
	[
		 "" : "--- None ---"
		"gordon_precriminal" : "Gordon pre-criminal" 
		"antlion_allied" : "Antlions are player allies" 
		"player_stealth" : "Player in APC is disguised as combine (unused)" 
		"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"
		"is_console" : "Game is running on a console"
		"is_pc" : "Game is running on a PC"
	]

	spawnflags(Flags) =
	[
		1 : "Remove on fire" : 1
	]
	
	output OnMapSpawn(void) : "Fired when the map is loaded for any reason including saves and round restarts."
	output OnNewGame(void) : "Fired when the map is loaded to start a new game."
	output OnLoadGame(void) : "Fired when the map is loaded from a saved game."
	output OnMapTransition(void) : "Fired when the map is loaded due to a level transition."
	output OnBackgroundMap(void) : "Fired when the map is loaded as a background to the main menu."
	output OnMultiNewMap(void) : "Fired only in multiplayer, when a new map is loaded."
	output OnMultiNewRound(void) : "Fired only in multiplayer, when a new round is started. Only fired in multiplayer games that use round-based gameplay."
]


@PointClass base(BaseEntity) iconsprite("editor/logic_branch") = logic_branch :
	"Tests a boolean value and fires an output based on whether the value is true or false. " +
	"Use this entity to branch between two potential sets of events."
[
	InitialValue(integer) : "Initial value" : : "Initial value for the boolean value (0 or 1)."
	
	input SetValue(bool) : "Set the boolean value without performing the comparison. Use this to hold a value for a future test."
	input SetValueTest(bool) : "Set the boolean value and test it, firing OnTrue or OnFalse based on the new value."
	input Toggle(void) : "Toggle the boolean value between true and false."
	input ToggleTest(void) : "Toggle the boolean value and tests it, firing OnTrue or OnFalse based on the new value."
	input Test(void) : "Test the input value and fire OnTrue or OnFalse based on the value."
	
	output OnTrue(bool) : "Fired when the input value is true (nonzero)." 
	output OnFalse(bool) : "Fired when the input value is false (zero)." 
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/logic_branch_listener") = logic_branch_listener :
	"Contains a list of logic_branch entities and fires outputs when the state of any of the logic_branches changes.\n\n"+
	"This entity is used to fire an event when a set of conditions are all satisfied."
[
	Branch01(target_destination) : "Logic Branch 01" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch02(target_destination) : "Logic Branch 02" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch03(target_destination) : "Logic Branch 03" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch04(target_destination) : "Logic Branch 04" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch05(target_destination) : "Logic Branch 05" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch06(target_destination) : "Logic Branch 06" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch07(target_destination) : "Logic Branch 07" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch08(target_destination) : "Logic Branch 08" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch09(target_destination) : "Logic Branch 09" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch10(target_destination) : "Logic Branch 10" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch11(target_destination) : "Logic Branch 11" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch12(target_destination) : "Logic Branch 12" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch13(target_destination) : "Logic Branch 13" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch14(target_destination) : "Logic Branch 14" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch15(target_destination) : "Logic Branch 15" : : "The name of one or more logic_branches (wildcards allowed)."
	Branch16(target_destination) : "Logic Branch 16" : : "The name of one or more logic_branches (wildcards allowed)."

	input Test(void) : "Tests the state of all the logic_branches in the list and fires the appropriate output."
	//Hammer doesn't like the _ at the beginning, these outputs don't seem to do anything
	//input _OnLogicBranchChanged(void) : "Appears to be a failed attempt at uncommenting the output."
	//input _OnLogicBranchRemoved(void) : Appears to be a failed attempt at uncommenting the output."

	output OnAllTrue(void) : "Fired when all the logic_branches in the list become true."
	output OnAllFalse(void) : "Fired when all the logic_branches in the list become false."
	output OnMixed(void) : "Fired when one of the logic branches in the list changes, but some are true and some are false."
]

@PointClass base(BaseEntity) iconsprite("editor/logic_case") = logic_case :
	"Compares an input to up to 16 preset values. If the input value is the same as " +
	"any of the preset values, an output corresponding to that value is fired.\n\n" +
	"For example: if Case01 is set to 2 and Case02 is set to 5, and the input value is 5, " +
	"the OnCase02 output will be fired.\n\n" +
	"This entity can also be used to select from a number of random targets via the " +
	"PickRandom input. One of the OnCase outputs that is connected to another entity will " +
	"be picked at random and fired."
[
	Case01(string) : "Case 01"
	Case02(string) : "Case 02"
	Case03(string) : "Case 03"
	Case04(string) : "Case 04"
	Case05(string) : "Case 05"
	Case06(string) : "Case 06"
	Case07(string) : "Case 07"
	Case08(string) : "Case 08"
	Case09(string) : "Case 09"
	Case10(string) : "Case 10"
	Case11(string) : "Case 11"
	Case12(string) : "Case 12"
	Case13(string) : "Case 13"
	Case14(string) : "Case 14"
	Case15(string) : "Case 15"
	Case16(string) : "Case 16"

	input InValue(string) : "Compares the Input value to the case values, and fires the appropriate output, if any."
	input PickRandom(void) : "Fires a random OnCase output with at least one connection."
	input PickRandomShuffle(void) : "Fires a random OnCase output with at least one connection, with no repeats until all cases have been picked, at which point the shuffle starts over."
	
	output OnCase01(void) : "Fired when the input value equals the Case01 value."
	output OnCase02(void) : "Fired when the input value equals the Case02 value."
	output OnCase03(void) : "Fired when the input value equals the Case03 value."
	output OnCase04(void) : "Fired when the input value equals the Case04 value."
	output OnCase05(void) : "Fired when the input value equals the Case05 value."
	output OnCase06(void) : "Fired when the input value equals the Case06 value."
	output OnCase07(void) : "Fired when the input value equals the Case07 value."
	output OnCase08(void) : "Fired when the input value equals the Case08 value."
	output OnCase09(void) : "Fired when the input value equals the Case09 value."
	output OnCase10(void) : "Fired when the input value equals the Case10 value."
	output OnCase11(void) : "Fired when the input value equals the Case11 value."
	output OnCase12(void) : "Fired when the input value equals the Case12 value."
	output OnCase13(void) : "Fired when the input value equals the Case13 value."
	output OnCase14(void) : "Fired when the input value equals the Case14 value."
	output OnCase15(void) : "Fired when the input value equals the Case15 value."
	output OnCase16(void) : "Fired when the input value equals the Case16 value."
	output OnDefault(void) : "Fired when the input value does not equal any of the Case values."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/logic_collision_pair") = logic_collision_pair : 
	"An entity that can be used to enables/disable vphysics collisions between two target entities."
[
	attach1(target_destination) : "Attachment 1" :  : "The first entity."
	attach2(target_destination) : "Attachment 2" :  : "The second entity."

	startdisabled(boolean) : "Start with collisions disabled?" : 1

	input EnableCollisions(void) : "Enable collisions between the first and second entity."
	input DisableCollisions(void) : "Disable collisions between the first and second entity."
]

@PointClass base(BaseEntity) iconsprite("editor/logic_compare") = logic_compare :
	"Compares an input value to another value. " +
	"If the input value is less than the compare value, the OnLessThan output is fired with the input value. " +
	"If the input value is equal to the compare value, the OnEqualTo output is fired with the input value. " +	
	"If the input value is greater than the compare value, the OnGreaterThan output is fired with the input value."
[
	InitialValue(integer) : "Initial value" : : "Initial value for the input value."
	CompareValue(integer) : "Compare value" : : "The value to compare against."
	
	input SetValue(float) : "Set the value that will be compared against the compare value."
	input SetValueCompare(float) : "Set the value that will be compared against the compare value and performs the comparison."
	input SetCompareValue(float) : "Set the compare value."
	input Compare(void) : "Force a compare of the input value with the compare value."
	
	output OnLessThan(float) : "Fired when the input value is less than the compare value. Sends the input value as data." 
	output OnEqualTo(float) : "Fired when the input value is equal to the compare value. Sends the input value as data." 
	output OnNotEqualTo(float) : "Fired when the input value is different from the compare value. Sends the input value as data." 
	output OnGreaterThan(float) : "Fired when the input value is greater than the compare value. Sends the input value as data."
]

@PointClass base(BaseEntity) = logic_eventlistener :
	"An entity that can listen to events fired from code and fire an output when it happens."
[
	EventName(string) : "Event Name" : "" : "The name of the event that you want to listen for."
	
	StartDisabled(boolean) : "Start Disabled" : 0

	input Enable(void) : "Enables this entity."
	input Disable(void) : "Disables this entity."
	input Toggle(void) : "Toggles this entity."
	
	output OnEventFired(void)  : "Fires when the event has been detected."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/logic_lineto") = logic_lineto : 
	"An entity that calculates and outputs a vector from one entity to another." 
[
	source(target_destination) : "Start entity" : : "Name of the entity the line should start from."
	target(target_destination) : "End entity" : : "Name of the entity that line should end at."
	
	output Line(vector) : "Fired when the vector, from the start entity to the end entity, changes. Passes along the vector as a parameter."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/logic_measure_movement") = logic_measure_movement :
	"An entity that can measure the movement of an entity relative to another entity and apply that movement to a third entity."
[
	MeasureTarget(target_destination) : "Entity to Measure" :  : "Entity whose movement you want to measure."
	MeasureReference(target_destination) : "Measure Reference" :  : "The movement of Entity to Measure will be measured relative to this entity."
	Target(target_destination) : "Entity to Move" :  : "This entity will be moved to mimic the motions of Entity to Measure."
	TargetReference(target_destination) : "Movement Reference" :  : "The Entity to Move will move relative to this entity."
	TargetScale(float) : "Movement scale" : "1" : "A scale to divide the measured movements by, before applying those movements to the Entity to Move. 1 = target entity moves as much as the measured entity, 2 = target entity moves half as far as the measured entity, and 0.5 = target entity moves twice as far as the measured entity."
	MeasureType(choices) : "Measurement Type" : 0 =
	[
		0 : "Position"
		1 : "Eye position"
	]
	
	input SetMeasureTarget(string) : "Set the Entity to Measure, whose movement should be measured."
	input SetMeasureReference(string) : "Set the Measure Reference entity."
	input Target(string) : "Set the Entity to Move, which will be moved to mimic the measured entity."
	input SetTargetReference(string) : "Set the Movement Reference entity."
	input SetTargetScale(float) : "Set the scale to divide the measured movements by."
	input Enable(void) : "Enable the logic_measure_movement."
	input Disable(void) : "Disable the logic_measure_movement."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/logic_mirror_movement") = logic_mirror_movement :
	"An entity that can mirror entity movement to another entity."
[
	m_target(target_destination)            : "Target entity"          :  : "Target entity."
	m_strMirrorTarget(target_destination)   : "Mirror Target entity"   :  : "Mirror target entity."
	m_strRemoteTarget(target_destination)   : "Remote Target entity"   :  : "Remote target entity."
	m_strMirrorRelative(target_destination) : "Mirror Relative entity" :  : "Mirror relative entity."
	
	input SetMirrorTarget(string) : "Set the Mirror Target entity."
	input SetTarget(string) : "Set the Target entity."
	input SetRemoteTarget(string) : "Set the Remove Target entity."
	input SetMirrorRelative(string) : "Set the Mirror Relative entity."
]

@PointClass base(BaseEntity) iconsprite("editor/logic_multicompare") = logic_multicompare :
	"Compares a set of inputs to each other. If they are all the same, fires an OnEqual output. " +
	"If any are different, fires the OnNotEqual output."
[
	IntegerValue(integer) : "Integer Value (optional)"
	ShouldComparetoValue(boolean) : "Should use Integer Value?" : 0

	input InputValue(integer) : "Input the value."
	input CompareValues(void) : "Compares the values and fires appropriate outputs."

	output OnEqual(void) : "Fires if the values are equal."
	output OnNotEqual(void) : "Fires if the values are not equal."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/logic_navigation") = logic_navigation : 
	"An entity that is used to set navigation properties on other entities. Useful to make NPCs ignore physics props in their way that they can easily push." 
[
	target(target_destination) : "Navigation Entity" : "" : "Name of the entity to set navigation properties on."
	navprop(choices) : "Navigation Property" : "Ignore" : "Changes the navigation properties type." =
	[
		"Ignore" : "NPCs Ignore this when navigating (they'll bump into it)"
	]
	
	spawnflags(flags) =
	[
		1 : "Start On" : 1
	]
	
	input TurnOn(void) : "Turn On. The Navigation Entity will have its navigation properties set."
	input TurnOff(void) : "Turn Off. The Navigation Entity will have its navigation properties returned to the default settings."
	input Toggle(void) : "Toggle on/off."
]

@PointClass base(BaseEntity, EnableDisable) iconsprite("editor-ficool2/logic_random") = logic_random :
	"Generates a random value between 2 bounds and outputs this value. The current value can also be accessed directly."
[
	min(integer) : "Minimum Random Value" : 0 : "Minimum random value for the counter."
	max(integer) : "Maximum Random Value" : 10 : "Maximum random value for the counter."

	input GenerateRandomValue(void): "Generates a random value and fires OutRandomValue."
	input GenerateRandomValueNoFire(void): "Generates a random value without firing any outputs."
	input SetRandomMax(float): "Set the upper bound of the random generator."
	input SetRandomMin(float): "Set the lower bound of the random generator."
	input GetRandomValue(void): "Causes the counter fire its OnGetRandomValue output with the current stored random value."
	
	output OutRandomValue(float) : "Fired when the random value is generated via GenerateRandomValue."
	output OnGetRandomValue(float) : "Fired in response to the GetRandomValue input."
]

@PointClass base(BaseEntity, EnableDisable) iconsprite("editor/logic_relay") = logic_relay :
	"A message forwarder. Fires an OnTrigger output when triggered, and " +
	"can be disabled to prevent forwarding outputs.\n\n" +
	"Useful as an intermediary between one entity and another for turning " +
	"on or off an I/O connection, or as a container for holding a set of " +
	"outputs that can be triggered from multiple places."
[
	spawnflags(flags) =
	[
		1: "Only Trigger Once" : 0
		2: "Allow Fast Retrigger - logic_relay doesn't 'sleep', bad for performance in great numbers" : 0
	]

	input Trigger(void) : "Trigger the relay, causing its OnTrigger output to fire if it is enabled."
	input Toggle(void) : "Toggle the relay between enabled and disabled."
	input CancelPending(void) : "Cancel any events fired by this relay that are currently pending in the I/O event queue."
	input EnableRefire(void) : "Allows the logic_relay to fire again, if the Allow Fast Retrigger flag is unticked."	
	
	output OnSpawn(void) : "Fired when the relay is spawned. If the relay is set to only trigger once, it will "+
		"delete itself after firing this output."
	output OnTrigger(void) : "Fired when the relay is triggered. If the relay is set to only trigger once, it will "+
		"delete itself after firing this output."
]

@PointClass base(BaseEntity, EnableDisable) iconsprite("editor/logic_timer") = logic_timer :
	"An entity that fires a timer event at regular, or random, intervals. It can also be set to oscillate between" + 
	"a high and low end, in which case it will fire alternating high/low outputs each time it fires."+
	"This entity uses a high amount of server bandwidth, especially with low refire intervals. Use a I/O loop with an entity such as logic_relay for those cases."
[
	RefireTime(string) : "Refire Interval" : : "If 'Use Random Time' isn't set, this is the time between timer fires, in seconds."
	LowerRandomBound(string) : "Minimum Random Interval" : : "If 'Use Random Time' is set, this is the minimum time between timer fires. The time will be a random number between this and the 'Maximum Random Interval'."
	UpperRandomBound(string) : "Maximum Random Interval" : : "If 'Use Random Time' is set, this is the maximum time between timer fires. The time will be a random number between the 'Minimum Random Interval' and this."
	UseRandomTime(boolean) : "Use Random Time?" : 0
	
	spawnflags(flags) =
	[
		1 : "Oscillator (alternates between OnTimerHigh and OnTimerLow outputs)" : 0
	]
	
	input RefireTime(integer) : "Set a new Refire Interval."
	input ResetTimer(void) : "Reset the timer. It will fire after the Refire Interval expires."
	input FireTimer(void) : "Force the timer to fire immediately."
	input Enable(void) : "Enable the timer, and resets it."
	input Disable(void) : "Disable the timer."
	input Toggle(void) : "Toggle the timer on/off."
	input LowerRandomBound(float) : "Set a new Minimum Random Interval."
	input UpperRandomBound(float) : "Set a new Maximum Random Interval."
	input AddToTimer(float) : "Add time to the timer if it is currently enabled.  Does not change the Refire Interval."
	input SubtractFromTimer(float) : "Subtract time from the timer if it is currently enabled.  Does not change the Refire Interval."

	output OnTimer(void) : "Fired when the timer expires."
	output OnTimerHigh(void) : "Fired every other time for an oscillating timer."
	output OnTimerLow(void) : "Fired every other time for an oscillating timer."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/material_modify_control") = material_modify_control : 
	"An entity that can be used to directly control material vars. To use it, you need to read the .vmt of the material you "+
	"intend to change. Parent this entity to a brush model entity who's material you want to control."
[
	materialName(string) : "Material to modify." 
	materialVar(string) : "Material variable to modify."

	input SetMaterialVar(string) : "Fire to modify a material variable. The argument is the value to set the variable to."
	input SetMaterialVarToCurrentTime(void) : "This sets the material variable to the current time on the server."
	input StartAnimSequence(string) : "Force an animated material with the MaterialModifyAnimated proxy to play a set of animation frames. Format is: <Frame Start> <Frame End> <Frame Rate> <Loop>\nSetting <Frame End> to -1 uses the last frame of the texture. <Loop> should be 1 or 0."
	input StartFloatLerp(string) : "Force a material with the MaterialModifyAnimated proxy to lerp a material var between two floating point values. Format is: <Start Value> <End Value> <Transition Time> <Loop>\n<Loop> should be 1 or 0."
] 

@PointClass base(BaseEntity) iconsprite("editor-ficool2/math_colorblend") = math_colorblend :
	"Used to create a blend between two colors for controlling the color of another entity."
[
	inmin(integer) : "Minimum Valid Input Value" : 0 : "Input values below this value will be ignored."
	inmax(integer) : "Maximum Valid Input Value" : 1 : "Input values above this value will be ignored."
	colormin(color255) : "Output RGB color when input is min." : "0 0 0" : "When the input value is equal to 'Minimum Valid Input Value', this is the output RGB color."
	colormax(color255) : "Output RGB color when input is max." : "255 255 255" : "When the input value is equal to 'Maximum Valid Input Value', this is the output RGB color."

	spawnflags(flags) = 
	[
		1 : "Ignore out of range input values" : 1
	]
	
	input InValue(float) : "Input value and fire the output with the remapped value."
	
	output OutColor(color255) : "Fired when the InValue input is received, with the remapped RGB color as the parameter."
]

@PointClass base(BaseEntity, EnableDisable) iconsprite("editor/math_counter") = math_counter :
	"Holds a numeric value and performs arithmetic operations upon it. If either the minimum or maximum " +
	"legal value is nonzero, OutValue will be clamped to the legal range, and the OnHitMin/OnHitMax " +
	"outputs will be fired at the appropriate times. If both min and max are set to zero, no clamping is " +
	"performed and only the OutValue output will be fired."
[
	startvalue(integer) : "Initial Value" : 0 : "Starting value for the counter."
	min(integer) : "Minimum Legal Value" : 0 : "Minimum legal value for the counter. If min=0 and max=0, no clamping is performed."
	max(integer) : "Maximum Legal Value" : 0 : "Maximum legal value for the counter. If min=0 and max=0, no clamping is performed."

	input Add(integer) : "Add an amount to the counter and fire the OutValue output with the result."
	input Divide(integer): "Divide the counter by an amount and fire the OutValue output with the result. Divisions by 0 will be ignored."
	input Multiply(integer): "Multiply the counter by an amount and fire the OutValue output with the result."
	input SetValue(integer): "Set the counter to a new value and fire the OutValue output with the result."
	input SetValueNoFire(integer): "Set the counter to a new value without firing any outputs."
	input Subtract(integer): "Subtract an amount from the counter and fire the OutValue output with the result."
	input SetHitMax(integer): "Set the upper bound of the counter and fire the OutValue output with the current value."
	input SetHitMin(integer): "Set the lower bound of the counter and fire the OutValue output with the current value."
	input GetValue(void): "Causes the counter fire its OnGetValue output with the current value of the counter. Used for polling the counter when you don't want constant updates from the OutValue output."
	
	output OutValue(integer) : "Fired when the counter value changes."
	output OnHitMin(void) : "Fired when the counter value meets or goes below the min value. The counter must go back above the min value before the output will fire again."
	output OnHitMax(void) : "Fired when the counter value meets or exceeds the max value. The counter must go below the max value before the output will fire again."
	output OnGetValue(integer) : "Fired in response to the GetValue input. Used for polling the counter when you don't want constant updates from the OutValue output."
]

@PointClass base(BaseEntity, EnableDisable) iconsprite("editor-ficool2/math_remap") = math_remap :
	"An entity that remaps a range of input values to a given range of output values."
[
	in1(integer) : "Minimum Valid Input Value" : 0 : "Input values below this value will be ignored."
	in2(integer) : "Maximum Valid Input Value" : 1 : "Input values above this value will be ignored."
	out1(integer) : "Output Value When Input Is Min." : : "When the input value is equal to 'Minimum Valid Input Value', this is the output value."
	out2(integer) : "Output Value When Input Is Max." : : "When the input value is equal to 'Maximum Valid Input Value', this is the output value."
	
	spawnflags(flags) = 
	[
		1 : "Ignore out of range input values" : 1
		2 : "Clamp output to output range" : 2
	]
	
	input InValue(float) : "Input value and fire the output with the remapped value."
	
	output OutValue(float) : "Fired when the InValue input is received, with the remapped input value as the parameter."
]

@SolidClass base(func_movelinear) = momentary_door :
	"Obsolete entity from Half-Life. Duplicate of func_movelinear."
[
]

@SolidClass base(BaseAnimatingBrush) = momentary_rot_button : 
	"A brush entity that's designed to be used for rotating wheels, where the player can rotate them to arbitrary positions before stopping."
[
	speed(integer) : "Speed (degree/second)" : 50 : "The amount, in degrees, that the wheel turns per second."
	sounds(choices) : "Sounds" : 0 = 
	[
		0: "None (Silent)"
		1: "Big zap & Warmup"
		2: "Access Denied"
		3: "Access Granted"
		4: "Quick Combolock"
		5: "Power Deadbolt 1"
		6: "Power Deadbolt 2"
		7: "Plunger"
		8: "Small zap"
		9: "Keycard Sound"
		10: "Buzz"
		11: "Buzz Off"
		12: "Latch locked"
		13: "Latch Unlocked"
		14: "Lightswitch"
		15: "Small bleek"
		16: "Small deny"
		17: "Small doop"
		18: "Small tech deny"
		19: "Click and combine screen fuzz"
		20: "Roomy beep"
		21: "Lever or Wheel: turn + move sqeek"
		22: "Lever or Wheel: latch + release gas"
		23: "Lever or Wheel: ratchet + sqeek"
		24: "Lever or Wheel: large ratchet"
		25: "Lever or Wheel: clanky + gas release"
		26: "Lever or Wheel: latch + large metal thud"
		27: "Lever or Wheel: smaller ratchet"
		28: "Lever or Wheel: smaller lever move"
		31: "Shock buzz"
		32: "Clickbeep"
		33: "Tech blip"
		34: "Clickbeepbeep open"
		35: "Small high blip"
		36: "Small tech fuzz blip"
		37: "Small click bleep (change to lightswitch)"
		40: "Combine door lock - locked"
		41: "Combine blip growl"
		42: "Combine squick growl"
		43: "Combine whine purr"
		44: "Combine click talk"
		45: "Combine click growl fizz"
		46: "Combine click fizz (deny)"
		47: "Combine click talker"
	]
	distance(integer) : "Distance" : 90 : "The maximum amount, in degrees, that the wheel is allowed to rotate."
	returnspeed(integer) : "Auto-return speed" : 0 : "If the 'Toggle' spawnflag is not set, the speed at which the wheel auto-returns when left alone, in degrees per second."
	startposition(float) : "Start Position" : 0 : "Position when spawned. The value is a range between 0.0 and 1.0, where 0 is the unrotated position and 1 is the rotated position + 'Distance'."
	startdirection(choices) : "Start Direction" : "Forward" : "Which way the wheel turns." =
	[
		-1 : "Forward"
		1 : "Backward"
	]
	solidbsp(boolean) : "Solid BSP?" : 0 : "Set this if this brush is in hierarchy with a moving object of some kind, and the player can stand on this brush."
	
	master(string) : "Master (Obsolete)" : : "Half-Life legacy support: The name of a master entity. If the master hasn't been activated, this button cannot be used."
	
	spawnflags(flags) =
	[
		1: "Not Solid" : 1
		32: "Toggle (Disable Auto Return)" : 1
		64: "X Axis" : 0
		128: "Y Axis" : 0
		1024: "Use Activates" : 1
		2048: "Starts locked" : 0
		8192: "Jiggle when used while locked" : 0
	]

	input Enable(void) : "Enable this button."
	input Disable(void) : "Disable this button."
	input Lock(void) : "Lock the button, preventing it from functioning."
	input Unlock(void) : "Unlock the button, allowing it to function."
	input SetPosition(string) : "Move to a position. The parameter must be a value between 0 and 1, where 0 is the unrotated position and 1 is the rotated position + 'Distance'."
	input SetPositionImmediately(string) : "Immediately teleport to a position. The parameter must be a value between 0 and 1, where 0 is the unrotated position and 1 is the rotated position + 'Distance'."

	output Position(integer)   : "Fired whenever the button moves. The output is the position of button from 0 to 1, where 0 is the unrotated position and 1 is the rotated position + 'Distance'."
	output OnPressed(integer)  : "Fired when the button is first pressed."
	output OnUnpressed(integer): "Fired when the button is first released from being pressed."
	output OnFullyClosed(void) : "Fired when the button has reached position 1, the rotated position + 'Distance'."
	output OnFullyOpen(void)   : "Fired when the button has reached position 0, the unrotated starting position."
	output OnReachedPosition(void)   : "Fired when the button has reached its position."
	output _DisableUpdateTarget(void)   : "Unknown function."
	output _EnableUpdateTarget(void)   : "Unknown function."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/multisource") = multisource : 
	"Half-Life legacy entity. Obsoleted by I/O in Source. Entity which lets mechanisms be created. It is the only entity that can be used as a 'master'."
[	
	target(target_destination) : "Target" : : "Entity to activate."
	globalstate(integer) : "Globalstate" : : "Unknown function."
	
	output OnTrigger(void) : "Fired when the entity is triggered."
]

@PointClass base(BaseObject) studioprop("models/buildables/dispenser.mdl") = obj_dispenser : 
	"The Dispenser. Gives health and ammunition to nearby players. The entity also spawns a vgui_screen entity, used for the metal counter screen."
[
	touch_trigger(target_destination) : "Custom Touch Trigger" : : "Touch Trigger to use instead as the healing zone, optionally."
]

@PointClass base(BaseObject) studioprop("models/buildables/sentry3.mdl") sphere(displayradius) = obj_sentrygun : 
	"The Sentry Gun. The Sentry Gun is a defensive building that rains gunfire on any enemies that come into range."
[
	displayradius(integer) : "Display Radius (Hammer Only)" : 1100 : "Keyvalue to display the range of the Sentry Gun in Hammer to assist with placement."
]

@PointClass base(BaseObject) studioprop("models/buildables/teleporter.mdl") = obj_teleporter : 
	"The Teleporter. A teleporter deploys players from one end into the other. 2 obj_teleporters should have linked Matching Teleporter keyvalues and the appropiate Type chosen." 
[
	teleporterType(choices) : "Type" : 1 =
	[
		1 : "Entrance"
		2 : "Exit"
	]
	
	matchingTeleporter(target_destination) : "Matching Teleporter" : : "The teleporter linked to this one."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/of_announcer") = of_announcer : 
    "Lets you change the default Announcer and make Announcer messages." 
[
    ForceAnnouncer(boolean) : "Force Announcer" : 0 : "Should we use this Announcer even if the User has a different one set."
    
    Announcer(string): "Announcer" : "" : "Sets the Default Announcer for this Map.\nBasegame Announcers: Announcer,Benja,Tyler"
    
    input AnnounceTeam(string) : "Make a team announcement. Format <teamname> <soundscript>"
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/of_gamemode_dm") = of_logic_dm : 
	"Sets the map to (Team) Deathmatch gamemode." 
[
	IsTeamplay(boolean) : "Is Teamplay?" : 0 : "Should the gamemode be Team Deathmatch?"
	DontCountKills(boolean) : "Don't Count Kills?" : 0 : "Don't count kills, for use with TDM."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/of_gamemode_dm") = of_logic_dom : 
	"Sets the map to Domination gamemode." 
[
	DomScoreLimit(integer) : "Score Limit" : 100 : "The score limit that teams will need to hit."
	DomScoreTime(integer) : "Score Time (seconds)" : 3 : "Every this amount of time, points will be added to the team(s) owning a control point"
	DomWinOnLimit(boolean) : "Win on Score Limit?" : 1 : "If set, the game will select a winner upon hitting the score limit."
	
	input AddDomScoreRed(integer) : "Add score to Red team. Negative values are allowed."
	input AddDomScoreBlue(integer) : "Add score to Blue team. Negative values are allowed."
	input SetDomScoreRed(integer) : "Set score of Red team."
	input SetDomScoreBlue(integer) : "Set score of Blue team."
	input SetDomScoreLimit(integer) : "Set the score limit for teams."
	
	output OnScoreLimitHitAny(void) : "Fired when any team hits the score limit."
	output OnScoreLimitHitRed(void) : "Fired when Red team hits the score limit."
	output OnScoreLimitHitBlue(void) : "Fired when Blue team hits the score limit."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/of_gamemode_dm") = of_logic_gg : 
	"Sets the map to the Gun Game gamemode." 
[
	ListOnly(boolean) : "List Only?" : 0 : "Don't initiate the Gamemode, used to make your own weapon pool without making the map default to Gun Game."
	RequiredKills(integer) : "Kills Per Level" : 2 : "How many kills are required to increase your level."
	WeaponName01(string) : "Weapon on Level 1" : : "Weapon given on this level."
	WeaponName02(string) : "Weapon on Level 2" : : "Weapon given on this level."
	WeaponName03(string) : "Weapon on Level 3" : : "Weapon given on this level."
	WeaponName04(string) : "Weapon on Level 4" : : "Weapon given on this level."
	WeaponName05(string) : "Weapon on Level 5" : : "Weapon given on this level."
	WeaponName06(string) : "Weapon on Level 6" : : "Weapon given on this level."
	WeaponName07(string) : "Weapon on Level 7" : : "Weapon given on this level."
	WeaponName08(string) : "Weapon on Level 8" : : "Weapon given on this level."
	WeaponName09(string) : "Weapon on Level 9" : : "Weapon given on this level."
	WeaponName10(string) : "Weapon on Level 10" : : "Weapon given on this level."
	
	WeaponName11(string) : "Weapon on Level 11" : : "Weapon given on this level."
	WeaponName12(string) : "Weapon on Level 12" : : "Weapon given on this level."
	WeaponName13(string) : "Weapon on Level 13" : : "Weapon given on this level."
	WeaponName14(string) : "Weapon on Level 14" : : "Weapon given on this level."
	WeaponName15(string) : "Weapon on Level 15" :  : "Weapon given on this level."
	WeaponName16(string) : "Weapon on Level 16" :  : "Weapon given on this level."
	WeaponName17(string) : "Weapon on Level 17" :  : "Weapon given on this level."
	WeaponName18(string) : "Weapon on Level 18" :  : "Weapon given on this level."
	WeaponName19(string) : "Weapon on Level 19" :  : "Weapon given on this level."
	WeaponName20(string) : "Weapon on Level 20" :  : "Weapon given on this level."	
	
	WeaponName21(string) : "Weapon on Level 21" :  : "Weapon given on this level."
	WeaponName22(string) : "Weapon on Level 22" :  : "Weapon given on this level."
	WeaponName23(string) : "Weapon on Level 23" :  : "Weapon given on this level."
	WeaponName24(string) : "Weapon on Level 24" :  : "Weapon given on this level."
	WeaponName25(string) : "Weapon on Level 25" :  : "Weapon given on this level."
	WeaponName26(string) : "Weapon on Level 26" :  : "Weapon given on this level."
	WeaponName27(string) : "Weapon on Level 27" :  : "Weapon given on this level."
	WeaponName28(string) : "Weapon on Level 28" :  : "Weapon given on this level."
	WeaponName29(string) : "Weapon on Level 29" :  : "Weapon given on this level."
	WeaponName30(string) : "Weapon on Level 30" :  : "Weapon given on this level."

	WeaponName31(string) : "Weapon on Level 31" :  : "Weapon given on this level."
	WeaponName32(string) : "Weapon on Level 32" :  : "Weapon given on this level."
	WeaponName33(string) : "Weapon on Level 33" :  : "Weapon given on this level."
	WeaponName34(string) : "Weapon on Level 34" :  : "Weapon given on this level."
	WeaponName35(string) : "Weapon on Level 35" :  : "Weapon given on this level."
	WeaponName36(string) : "Weapon on Level 36" :  : "Weapon given on this level."
	WeaponName37(string) : "Weapon on Level 37" :  : "Weapon given on this level."
	WeaponName38(string) : "Weapon on Level 38" :  : "Weapon given on this level."
	WeaponName39(string) : "Weapon on Level 39" :  : "Weapon given on this level."
	WeaponName40(string) : "Weapon on Level 40" :  : "Weapon given on this level."	
	
	WeaponName41(string) : "Weapon on Level 41" :  : "Weapon given on this level."
	WeaponName42(string) : "Weapon on Level 42" :  : "Weapon given on this level."
	WeaponName43(string) : "Weapon on Level 43" :  : "Weapon given on this level."
	WeaponName44(string) : "Weapon on Level 44" :  : "Weapon given on this level."
	WeaponName45(string) : "Weapon on Level 45" :  : "Weapon given on this level."
	WeaponName46(string) : "Weapon on Level 46" :  : "Weapon given on this level."
	WeaponName47(string) : "Weapon on Level 47" :  : "Weapon given on this level."
	WeaponName48(string) : "Weapon on Level 48" :  : "Weapon given on this level."
	WeaponName49(string) : "Weapon on Level 49" :  : "Weapon given on this level."
	WeaponName50(string) : "Weapon on Level 50" :  : "Weapon given on this level."

]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/of_gamemode_dm") = of_logic_esc : 
	"Sets the map to the Escort gamemode." 
[
	MaxRedHunted(integer) : "RED Hunted Count" : 0 : "How many Civilians the RED team will have."
	MaxBluHunted(integer) : "BLU Hunted Count" : 0 : "How many Civilians the BLU team will have."
	
	output OnHuntedDeath(void) : "Fired when a Hunted dies."
]

@PointClass base(BaseEntity, EnableDisable, TeamNum) size(-8 -8 -8, 8 8 8) studioprop() = of_music_player :    
    "Music handler Entity." 
[
    Index(integer) : "Index" : 0 : "Index used to pull from MapData"
    WaitingForPlayers(boolean) : "Waiting for Players Music" : 0 : "Play in waiting for players instead of while the round is going on."
    
    IntroSongName(sound): "Song Intro" : "" : "Intro of the song, transitions into Song Loop."
    LoopingSongName(sound): "Song Loop" : "" : "The Looping part of the song, only happens once if there is no loop."    
    OutroSongName(sound): "Song End" : "" : "The end of the song, only play when the song loop gets disabled and the loop ends or if its forced to end."    

]

@SolidClass base(Trigger) = ofd_trigger_jump : 
    "Bounces players to the target."
[
	target(target_destination) : "Target" : "" : "Name of entity we'll bounce players to."
	apex_height_boost(float) : "Apex Height Increase" : "0" : "Used to increase the height of our apex. Higher apex = bigger arc." 
	
	soft_landing(boolean) : "Soft Landing?" : 0 : "Should launched players take no fall/impact damage?"
	
	output OnJump(void) : "Fired when a player (or object) are bounced."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/path_corner") line(255 255 255, targetname, target) = path_corner : 
    "Generic path point for moving entities such as NPCs."
[
	target(target_destination) : "Next path_corner" : : "Next stop target after this one."
	wait(integer) : "Wait Here for... (seconds)" : 0 : "Wait at this point for <seconds>."
	speed(integer) : "New Speed" : 0 : "The speed to override on the entity which passed it."
	
	spawnflags(Flags) =
	[
		1: "Wait for retrigger" : 0
		2: "Teleport to THIS path_corner" : 0
	]

	input SetNextPathCorner(string) : "Sets next path_corner."
	input InPass(void) : "The entity is passing this point, fires OnPass."
	
	output OnPass(void) : "Fires when a path follower passes this point"
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/path_track") sphere(radius) line(255 255 255, targetname, target) = path_track : 
	"An entity used to build paths for other entities to follow. Each path_track is a node on the path, each holding the name of the next path_track in the path."
[
	target(target_destination) : "Next Stop Target" : : "The next path_track in the path."
	altpath(target_destination) : "Branch Path" : : "An alternative path_track to be the next node in the path. Useful for making branching paths. Use the ToggleAlternatePath / EnableAlternatePath inputs to make the alternative path active."
	speed(float) : "New Train Speed" : 0 : "When the train reaches this path_track, it will set its speed to this speed. "+
		"This speed must be a positive value that is less than the train's max speed. A value of 0 will cause no change in the train's speed."
	radius(float) : "Path Radius" : 0 : "Used by NPCs who follow track paths (attack chopper/gunship). This tells them the maximum distance they're allowed to be from the path at this node."
	orientationtype(choices) : "Orientation Type" : 1 : "The way that the path follower faces as it moves through this path track." =
	[
		0 : "No change"
		1 : "Face direction of motion"
		2 : "Face this path_track's angles"
	]

	spawnflags(Flags) =
	[
		1:  "Disabled" : 0
		2:  "Fire once" : 0
		4:  "Branch Reverse" : 0
		8:  "Disable train" : 0
		16: "Teleport to THIS path track" : 0
		32: "Rollback zone on HUD (auto-roll if team_train_watcher handles movement)" : 0
		64: "Rollforward zone on HUD (auto-roll if team_train_watcher handles movement)" : 0
	]
	
	input ToggleAlternatePath(void) : "Cause the track to toggle to/from its alternate path."
	input EnableAlternatePath(void) : "Enable the alternate path of the track."
	input DisableAlternatePath(void) : "Disable the alternate path of the track."
	input TogglePath(void) : "Cause the track to toggle on/off/"
	input EnablePath(void) : "Enable the track."
	input DisablePath(void) : "Disable the track."
	input InPass(void) : "The entity is passing this point, fires OnPass."
	
	output OnPass(void) : "Fired when any entity following this path passes this path_track node."
	output OnTeleport(void)  : "Fired when any entity following this path teleports directly to this path_track node."
]

@PointClass base(TwoObjectPhysics) iconsprite("editor/phys_ballsocket") = phys_ballsocket : 
	"A constraint that keeps the position of two objects fixed, relative to the constraint's origin. It does not affect rotation."
[
]


@PointClass base(TwoObjectPhysics) studioprop("models/editor/axis_helper.mdl") = phys_constraint : 
	"A constraint that keeps the relative position and orientation of two objects fixed. Recommended to be used with phys_constraintsystem."
[
]
	
@PointClass base(BaseEntity) iconsprite("editor-ficool2/phys_constraintsystem")  = phys_constraintsystem : 
	"An entity used to manage a group of interacting constraints and keep them stable. " +
	"All constraints on a set of entities should be placed in the same system, or they will fight each other during simulation."
[
	additionaliterations(integer) : "Additional System Iterations" : 0 : "Adding iterations makes the interactions among constraints in a system tighter.  It will not compensate for errors due to collision, but will help in cases where objects of disparate mass are constrained to each other."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/phys_convert") = phys_convert : 
	"Turns an arbitrary entity into a physically simulated entity. i.e. brush entities will behave like func_physbox, model entities behave like prop_physics. Brush entities will turn into simple_physics_brush and model entities will turn into simple_physics_prop."
[
	target(target_destination) : "Entity to Convert" : : "Name of the entity that will be converted to a physics object when the ConvertTarget input is fired."
	swapmodel(studio) : "Model Swap Entity" : : "If specified, the model of the entity specified here will replace the model of the target object when it is converted."
	massoverride(float) : "Mass Override" : "0" : "Sets the mass when the object(s) are converted (0 means auto-calculate)."

	spawnflags(flags) =
	[
		1: "Convert Asleep" : 0
		2: "Convert As Debris" : 0
	]

	input ConvertTarget(void) : "Converts this entity's target to a physically simulated object. Only name, model, and velocity are retained after conversion. No keyvalues, e.g. skin and color, are kept. AddOutput could be used as a workaround depending on the circumstances." 
	
	output OnConvert(void) : "Fires after the conversion has taken place."
]

@PointClass halfgridsnap iconsprite("editor-ficool2/phys_hinge") base(TwoObjectPhysics) = phys_hinge : 
	"A physically simulated hinge. Use the helper to define the axis of rotation."
[
	hingefriction(float) : "Friction" : "0" : "Resistance/friction in the hinge"
	hingeaxis(vecline) : "Hinge Axis"
	SystemLoadScale(float) : "Load Scale" : "1" : "Scale of the load connected to this hinge (1=just the objects directly connected)"
	
	minSoundThreshold(float) : "Minimum Sound Velocity" : "6" : "When travelling below this many units/sec, will not play any sound."
	maxSoundThreshold(float) : "Full Sound Velocity" : "80" : "When travelling at this speed or above, will play sound at full volume."
	slidesoundfwd(sound) : "Travel sound (forward)" :  : "Play this sound when travelling forward on helper axis"
	slidesoundback(sound) : "Travel sound (backward)" :  : "Play this sound when travelling backward on helper axis"
	
	input SetAngularVelocity(float) : "Set angular velocity around the hinge (motor) in deg/sec."
	input SetHingeFriction(float) : "Set the resistance/friction in the hinge."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/phys_keepupright")  = phys_keepupright : 
    "A controller that tries to keep an entity facing a particular direction. This works on parented entities, allowing their angles to be constrained."
[
	attach1(target_destination) : "Target Entity" :  : "The entity to align to the desired angles."
	angularlimit(float) : "Angular Limit" : "15" : "The maximum angular velocity that this controller can compensate for, in degrees per second."
	
	spawnflags(flags) =
	[
		1: "Start inactive" : 0
	]
	input TurnOn(void) : "Enable the controller."
	input TurnOff(void) : "Disable the controller." 
]

@PointClass base(TwoObjectPhysics) studioprop("models/editor/axis_helper.mdl") = phys_lengthconstraint : 
	"A constraint that preserves the distance between two entities. If the 'Keep Rigid' flag is set, think of it as a rod. If not, think off it as a virtual rope."
[
	addlength(float) : "Additional Length" : "0" : "Add (or subtract) this amount to the rest length of the rope."
	minlength(float) : "Minimum Length" : "0" : "If the constraint is not rigid, this is the minimum length it can be."
	attachpoint(vecline) : "Attached object 2 point" : "The position the rope attaches to object 2"
	
	spawnflags(flags) =
	[
		1: "No Collision until break" : 1
		2: "Keep Rigid" : 0
	]
]

@PointClass base(Model, BaseAnimating) studioprop() = phys_magnet : 
	"An entity that acts like a magnet, attaching metallic physics objects to itself when they touch it. The game will crash if no model is specified! "+
	"Coast jeep pickup hack flag: In HL2, prevent objects from interfering with the crane as it picks up the buggy. It is hardcoded for use with prop_vehicle_jeep only. Another entity can be used by changing the entity's classname to prop_vehicle_jeep using AddOutput. "+
	"However, if the game round restarts in multiplayer, the entity will no longer function and will cause crashes (this can be fixed by clearing the classname again with AddOutput to the original)."
[
	forcelimit(float) : "Force Limit to Break (lbs)" : "0" : "The amount of force necessary to break a stuck object off the magnet. A way of calculating this is to set it to the mass of an object that would break this constraint if it were resting on the magnet."
	torquelimit(float) : "Torque Limit to Break (lbs * distance)" : "0" : "The amount of torque necessary to break a stuck object off the magnet. A way of calculating this is to multiply any reference mass by the resting distance (from the center of mass of the object) needed to break the constraint."
	massScale(float) : "Mass Scale" : "0" : "A scale multiplier for the object's mass."
	overridescript(string) : "Override parameters" :  : "A list of physics key/value pairs that are usually in a physics prop .qc file. Format is 'key,value,key,value,etc'."
	maxobjects(integer) : "Maximum Attached Objects" : 0 : "The maximum number of physics objects that can be stuck to the magnet at once. 0 = no limit."

	spawnflags(flags) =
	[
		1 : "Start Asleep" : 0
		2 : "Motion Disabled" : 0
		4 : "Suck On Touch" : 0
		8 : "Allow Attached Rotation" : 0
		16: "Coast jeep pickup hack - see description" : 0
	]
	
	input TurnOn(void) : "Turn the magnet on."
	input TurnOff(void) : "The the magnet off. This will detach anything current stuck to the magnet."

	output OnAttach(void) : "Fired when an entity is grabbed by the magnet."
	output OnDetach(void) : "Fired when an entity is released by the magnet."
]

@PointClass base(BaseEntityPoint) halfgridsnap iconsprite("editor-ficool2/phys_motor") = phys_motor : 
	"An entity that tries to spin a target entity at a particular speed."
[
	attach1(target_destination) : "Attached Object" :  : "Object to apply the force to."
	speed(string) : "Rotation Speed" : "0" : "Angular speed (units are degress/second)"
	spinup(string) : "Spin up time" : "1" : "spin up time in seconds (also affects the rate at which speed changes happen)"
	inertiafactor(float) : "System Interia Scale" : "1.0" : "Make this larger if the object being driven is constrained to a set of heavier objects."
	axis(vecline) : "Rotation Axis" :  : "The point to the origin of the entity whose line the rotation axis."

	spawnflags(flags) =
	[
		1: "Start On" : 1
		2: "No world collision" : 0
		4: "Hinge Object - Motor also acts as a hinge constraining the object to this axis" : 1
		8: "Orient Locally - Maintain local relationship with the attached object" : 1
	]

	input SetSpeed(float) : "Sets target speed."
	input TurnOn(void) : "Turns motor on."
	input TurnOff(void) : "Turns motor off."
]

@PointClass base(TwoObjectPhysics) studioprop("models/editor/axis_helper.mdl") = phys_pulleyconstraint : 
	"A constraint that is essentially two length constraints and two points. Imagine it as a virtual rope connected to two objects, each suspended from a pulley above them."+
	"The constraint keeps the sum of the distances between the pulley points and their suspended objects constant."
[
	addlength(float) : "Additional Length" : "0" : "Add (or subtract) this amount to the rest length of the pulley rope."
	gearratio(float) : "Pulley Gear Ratio" : "1" : "Add (or subtract) this amount to the rest length of the pulley rope."
	position2(vecline) : "Pulley Position 2" : : "The position of the pulley for Entity 2. The pulley for Entity 1 is the origin of this constraint entity. Entity 1 is always suspended from pulley point 1, and Entity 2 is always suspended from pulley point 2."

	spawnflags(flags) =
	[
		1: "No Collision until break" : 1
		2: "Keep Rigid" : 0
	]
]

@PointClass base(TwoObjectPhysics) studioprop("models/editor/axis_helper.mdl") = phys_ragdollconstraint : 
	"A constraint that fixes the position of two entities, relative to this constraint's origin. Also allows for limits on the rotation around each axis, in the space of this constraint."
[
	xmin(float) : "X axis min limit" : "-90" : "-180 min and 180 max = no constraint on this axis."
	xmax(float) : "X axis max limit" : "90" : "-180 min and 180 max = no constraint on this axis."
	ymin(float) : "Y axis min limit" : "0" : "-180 min and 180 max = no constraint on this axis."
	ymax(float) : "Y axis max limit" : "0" : "-180 min and 180 max = no constraint on this axis."
	zmin(float) : "Z axis min limit" : "0" : "-180 min and 180 max = no constraint on this axis."
	zmax(float) : "Z axis max limit" : "0" : "-180 min and 180 max = no constraint on this axis."
	xfriction(float) : "X axis friction" : "0"
	yfriction(float) : "Y axis friction" : "0"
	zfriction(float) : "Z axis friction" : "0"
	
	spawnflags(flags) =
	[
		1: "No Collision until break" : 1
		2: "Only limit rotation (free movement)" : 0
	]
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/phys_ragdollmagnet") sphere(radius) = phys_ragdollmagnet : 
	"An entity that acts like a magnet for ragdolls. Useful for crafting exaggerated ragdoll behavior (i.e. guys falling over rails on death). If the "+
	"Bar Magnet spawnflag is set, the magnet works like it was a cylindrical magnet i.e. it attracts ragdolls to the nearest point on a line."
[
	target(string) : "Entity to affect" :  : "If specified, the phys_ragdollmagnet will only affect the target entity."
	axis(vecline) : "Bar Magnet Axis" : : "Axis of the bar magnet, if the spawnflag is active."
	radius(float) : "Effective Radius" : "512" : "Radius in which ragdolls are affected around this entity's origin."
	force(float) : "Force" : "5000" : "Magnetic force to apply to ragdolls within the radius. Expressed as kilograms per inch per second. So a force of 1000 will add 10 units/second to a 100kg man. It will add 100 units per second to a 10kg headcrab."

	spawnflags( Flags ) =
	[
		2 : "Bar Magnet (use axis helper)" : 0
	]
]

@PointClass halfgridsnap base(TwoObjectPhysics) studioprop("models/editor/axis_helper.mdl") = phys_slideconstraint : 
	"A constraint that constrains an entity along a line segment."
[
	slideaxis(vecline) : "Sliding Axis" : "Axis of the constraint. Usually set with the Hammer helper tool."
	slidefriction(float) : "Friction" : "0" : "Resistance/friction in the constraint,"
	SystemLoadScale(float) : "Load Scale" : "1" : "Scale of the mass load connected to this constraint (1=just the objects directly connected)."
	
	spawnflags(flags) =
	[
		1: "No Collision until break" : 1
		2: "Limit Endpoints" : 0
	]	
	
	input SetVelocity(float) : "Set linear velocity along the constraint."
]

@PointClass halfgridsnap base(BaseEntityPoint) iconsprite("editor-ficool2/phys_spring") = phys_spring : 
	"A physically simulated spring. "+
	"'Length' is what's known as the 'natural spring length'. This is how long the spring would "+
	"be if it was at rest (nothing hanging on it or attached). When you attach something to the "+
	"spring, it will stretch longer than its 'natural length'. The amount of stretch is "+
	"determined by the 'Sprint Constant'. The larger the spring constant the less stretch the spring."
[
    attach1(target_destination) : "Entity 1" : ""
    attach2(target_destination) : "Entity 2" : ""

	springaxis(vecline) : "Spring Axis" :  : "Use the helper. Drag it out to match the virtual spring."
	length(string) : "Spring Length" : "0" : "How long the spring would be if it was at rest (nothing hanging on it or attached). 0 means the length of the brush."
	constant(string) : "Spring Constant" : "50" : "Stiffness of the spring.  The larger the number the less the spring will stretch."
	damping(string) : "Damping Constant" : "2.0" : "How much energy the spring loses.  The larger the number, the less bouncy the spring."
	relativedamping(string) : "Relative Damping Constant" : "0.1" : "The amount of energy the spring loses proportional to the relative velocity of the two objects the spring is attached to."
	breaklength(string) : "Break on Length" : "0" : "If the spring's length ever exceeds this length, the spring breaks."

	spawnflags(flags) =
	[
		1 : "Force only on stretch" : 0
	]
	
	input SetSpringConstant(float) : "Set the Spring Constant."
	input SetSpringLength(float) : "Set the Spring Length."
	input SetSpringDamping(float) : "Set the Spring Damping."
]

@PointClass base(BaseEntityPoint) studioprop("models/editor-ficool2/cone_helper_gray.mdl") = phys_thruster : 
	"An entity used to apply constant acceleration to a physics object. "+
	"The force and torque is calculated using the position and direction of the thruster as an impulse. So moving those off the object's center "+
	"will cause torque as well. Torque can be removed by unchecking the 'apply torque' flag. The position of the thruster can be forced to be "+
	"at the object's center by checking to 'Ignore Position' flag."
[
	attach1(target_destination) : "Attached Object" :  : "Object to apply the force to."
	forcetime(string) : "Time of Force (0=inf)" : "0" : "Automatic shut-off after this time has passed (0 = stay on forever or until deactivated)"
	force(string) : "Force" : "0" : "Force (will be integrated, units are force kg*in/s^2). Negative values are accepted."
	
	spawnflags(flags) =
	[
		1: "Start On" : 0
		2: "Apply Linear Force" : 1
		4: "Apply Torque (rotational force)" : 1
		8: "Orient Locally - Maintain local relationship with the attached object" : 1
		16: "Ignore Mass - Impulse is independent of object's mass (impulse is acceleration NOT force)" : 0
		32: "Ignore Position -  Put the thrust at the object center" : 0
	]	
	
	input Activate(void) : "Turn the force on."
	input Deactivate(void) : "Turn the force off."
	input Scale(string) : "Set Force Scale, negative values are accepted."
]

@PointClass halfgridsnap base(BaseEntityPoint) studioprop("models/editor-ficool2/cone_helper_gray.mdl") = phys_torque : 
	"An angular thruster. Use it to apply angular force to an entity."
[
	attach1(target_destination) : "Attached Object" :  : "Object to apply the force to."
	force(string) : "Angular Acceleration" : "0" : "Axial acceleration acting on the object (units are degress/s^2). Negative values are accepted."
	forcetime(string) : "Time of Force (0=inf)" : "0" : "Automatic shut-off after this time has passed (0 = stay on forever or until deactivated)"
	axis(vecline) : "Rotation Axis" :  : "The point to the origin of the entity whose line the rotation axis."
	
	spawnflags(flags) =
	[
		1: "Start On" : 0
		2: "Apply Linear Force" : 1
		4: "Apply Torque (rotational force)" : 1
		8: "Orient Locally - Maintain local relationship with the attached object" : 1
		16: "Ignore Mass - Impulse is independent of object's mass (impulse is acceleration NOT force)" : 0
	]

	input Activate(void) : "Turn the force on."
	input Deactivate(void) : "Turn the force off."
	input Scale(string) : "Set Force Scale, negative values are accepted."
]

@PointClass base(BaseAnimating) sphere(expradius) studioprop() = physics_cannister : 
	"A physically simulated gas cannister that can have its cap shot off, at which point gas will start escaping and cause the cannister to fly around. If it takes enough damage, it will explode. "+
	"Follows the same rules as prop_physics for simulation."
[
	model(studio) : "Model" : "models/props_c17/canister02a.mdl" : "The model this entity should appear as. The model should have a nozzle attachment point, which is where gas will escape and thrust will be produced from. Must be compiled with $staticprop to allow usage." 

	expdamage(string) : "Explosion Damage" : "200.0" : "The amount of damage done by the explosion created when the cannister blows up."
	expradius(string) : "Explosion Radius" : "250.0" : "The radius of the explosion to create when the cannister blows up."
	health(integer) : "Health" : 25 : "The amount of damage the cannister takes before exploding."

	thrust(string) : "Thrust" : "3000.0" : "When the cap has been blown off, and the escaping gas is thrusting the cannister about, this is the amount of thrust generated."
	fuel(string) : "Fuel (Seconds)" : "12.0" : "The amount of time that gas leaks from the cannister before being considered empty."
	rendercolor(color255) : "Smoke Color (R G B)" : "255 255 255" : "Color of the smoke."
	renderamt(integer) : "Smoke Alpha (0 - 255)" : 128 : "Transparency of the smoke."
	gassound(sound) : "Thruster Sound" : "PhysicsCannister.ThrusterLoop" : "The sound played when the gas is escaping from the cannister."

	spawnflags(flags) = 
	[
		1 : "Start Asleep" : 0
		2 : "Explodes" : 1
	]
	
	input Activate(string) : "Start gas escaping from the cannister."
	input Deactivate(string) : "Stop gas escaping from the cannister."
	input Explode(string) : "Force the cannister to explode."
	input Wake(void) : "Wakes up the cannister, if it is sleeping."

	output OnActivate(void) : "Fired when gas starts to escape from the cannister."
	output OnAwakened(void) : "Fired when this entity becomes awake (collision/force is applied)."
]

@PointClass base(TeamNum) studioprop("models/player.mdl") = player : 
	"The player itself. Do not place this entity in a map, it will result in an instant crash! The keyvalues should be changed at runtime with AddOutput."
[
	health(float) : "Health" : 125 : "Current health of the player. Cannot exceed Maximum Health. Decimals are accepted, although not shown in the HUD."
	max_health(float) : "Maximum Health" : 125 : "Maximum health of the player. Decimals are accepted."
	gravity(float) : "Gravity" : "1" : "The player's gravity. Default is 1. Does not allow a value of 0, use a number like 0.0001 instead. Negative values are accepted. Custom gravity values will not have any lag compensation, resulting in jittery movement."
	view_ofs(vector) : "View Offset" :  : "Offsets the player's camera by a X and Y vector (possibly Z, needs more testing). The player will not have any physical camera change unless in thirdperson, although all attacks will be offset from the crosshair."
	velocity(vector) : "Local Velocity" :  : "Velocity generated by the player, can cause strange behavior if changed with AddOutput."
	basevelocity(vector) : "Base Velocity" :  : "Velocity to add onto the player."
	avelocity(vector) : "Angular Velocity" :  : "Angular velocity to add onto the player."
	waterlevel(float) : "Water Level" :  : "Current water level of the player, can cause strange behavior if changed with AddOutput."
	ResponseContext(string) : "Response Contexts" :  : "Response system context(s) for this entity. Format should be: 'key:value,key2:value2,etc'. When this entity speaks, the list of keys & values will be passed to the response rules system."

    // BLOCKCIVILIANBASTARD MOMENT
	input SetCustomModel(string) : "Sets a custom model on the player."
	input StripWeapons(void) : "Strips all weapons on the player."
	input AddMoney(float) : "Adds or subtracts money on the player."
	input SetMoney(float) : "Sets the money to a specied amount on the player."
	input SetHealth(float) : "Sets the player's health. Values clamped between 0 and Maximum Health. In TF2, health above the Maximum Health will be counted as overheal."
	input HandleMapEvent(string) : "Tells the game to perform a function, such as unlock an achievement. Hardcoded for specific map names."
	input SetHudVisibility(bool) : "Hides or displays the HUD. The menu can still be accessed, and some HUD elements such as kill-icons may still be visible. 1 = visibile, 0 = invisible."
	input SetFogController(string) : "Sets the fog controller to use."
	input DispatchResponse(string) : "Dispatches a response to the player."
	
	input AddContext(string) : "Adds a context to this player's list of response contexts. The format should be 'key:value'."
	input RemoveContext(string) : "Remove a context from this player's list of response contexts. The name should match the 'key' of a previously added context."
	input ClearContext(void) : "Removes all contexts in this player's list of response contexts."	
	
	input RoundSpawn(void) : "Spawns the player, fired automatically."
]



@PointClass base(BaseEntity) iconsprite("editor-ficool2/player_speedmod") = player_speedmod:
    "Speeds up or slows down player velocity."
[
	spawnflags(Flags) =
	[
		1: "Suppress weapons" : 0
		2: "Suppress HUD" : 0
		4: "Suppress jump" : 0
		8: "Suppress duck" : 0
		16: "Suppress +use" : 0
		32: "Suppress sprint" : 0
		64: "Suppress attack" : 0
		128: "Suppress zoom" : 0
	]

	input ModifySpeed(float) : "Modifies player speed by X ammount."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/player_weaponstrip") = player_weaponstrip : 
   "Strips a player's weapons."
[
	input Strip(void) : "Strip the !activator's weapons."
	input StripWeaponsAndSuit(void) : "Strip the !activator's weapons and suit."
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/point_anglesensor") = point_anglesensor :
	"An entity that detects if another entity points in a given direction for a period of time."
[
	target(target_destination) : "Target Entity Name" : : "Name of the entity whose angles will be sensed."
	lookatname(target_destination) : "Look At Entity" : : "The entity we want to check to see if the Target Entity is looking at."
	duration(float) : "Duration" : : "The amount of time the Target Entity must look at the 'Look at Entity' to trigger this entity, in seconds."
	tolerance(integer) : "Tolerance" : : "The tolerance, in degrees, in the checking to determine when the Target Entity is looking at the Look At Entity."

	spawnflags(Flags) =
	[
		1 : "Use target entity's angles (NOT position)" : 0
	]
	
	input Toggle(void) : "Toggle the sensor between enabled and disabled."
	input Test(void) : "Check to see if the Target Entity is facing the Look At Entity within the specified tolerance, firing either the OnFacingLookat or OnNotFacingLookat output based on the result."
	input SetTargetEntity(void) : "Set the target entity to sense angles."
	
	output TargetDir(vector) : "Fired when the forward direction of the Target Entity changes. Passes the new forward direction as a parameter."
	output OnFacingLookat(void) : "Fired when the Target Entity points at the Look At Entity for more than the specified Duration, or in response to a Test input."
	output OnNotFacingLookat(void) : "Fires in response to a Test input when the Target Entity is not pointing at the Look At Entity."
	output FacingPercentage(float) : "Normalized value (0..1) where 1 is facing directly at target and 0 is at or beyond the angle of tolerance."
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/point_angularvelocitysensor") = point_angularvelocitysensor :
	"An entity that detects if another entity's angular velocity meets or exceeds a threshold value. The AngularVelocity is fired every frame, so use with caution!"
[
	target(target_destination) : "Target Entity Name" : : "Name of the entity whose angular velocity will be sensed."
	threshold(float) : "Threshold Velocity" : 0 : "The threshold angular velocity to compare against, in degrees per second."
	fireinterval(float) : "Fire Interval" : "0.2" : "Angular velocity must cross the threshold for at least this long to fire."
	axis(vecline) : "Axis" : : "The axis to measure for."
	usehelper(boolean) : "Use Axis Helper?" : 0 : "Use axis helper to determine rotation values (clockwise/counter-clockwise)."

	input Test(void) : "Checks to see if the Target Entity's angular velocity meets or exceeds the Threshold Velocity, " +
		"firing either the OnGreaterThanOrEqualTo or OnLessThan output based on the result."

	input TestWithInterval(void) : "Checks to see if the Target Entity's angular velocity meets or exceeds the Threshold Velocity. Once the Fire Interval expires, " +
		"fires the appropriate test result output if the result is stable throughout the Fire Interval."
	
	output AngularVelocity(float) : "Fired when the Target's Angular Velocity changes, passing the new magnitude of the angular velocity."
	output OnGreaterThan(void) : "Fired when the Target Entity goes from slower than the threshold angular velocity to faster than the threshold angular velocity."
	output OnGreaterThanOrEqualTo(void) : "Fired when the Target Entity goes from slower than the threshold angular velocity to faster than the threshold angular velocity."
	output OnLessThan(void) : "Fired when the Target Entity goes from faster than the threshold angular velocity to slower than the threshold angular velocity."
	output OnLessThanOrEqualTo(void) : "Fired when the Target Entity goes from faster than the threshold angular velocity to slower than the threshold angular velocity."
	output OnEqualTo(void) : "Fired when the Target Entity reaches the threshold angular velocity from a different velocity."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_clientcommand") = point_broadcastclientcommand : 
	"An entity that issues commands to each valid client's console, as if it was typed in by that player locally."
[
	input Command(string) : "Command to execute."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_bonusmaps_accessor") = point_bonusmaps_accessor : 
	"An entity that relays bonus maps changes. "
[
	filename(string) : "File Name" :  : "Link to a .BNS file with values for this map. Relative to mod's root directory."
	mapname(string) : "Map Name" :  : "Script entry inside above .BNS file of the map. This is NOT .bsp file name."

	input Unlock(void) : "Unlocks the filename/map combination."
	input Complete(void) : "Completes the filename/map combination."
	input Save(void) : "Saves bonus map data."
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/camera.mdl") = point_camera : 
    "The view of this camera entity can be output in realtime to a func_monitor's monitor surface, or alternatively (using info_camera_link) to any named brush entity using the correct monitor texture. Active cameras require one render texture each. Does not render anything in Team Fortress 2."
[
	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" : 1024 : "Width/height of the render target for the camera."
	UseScreenAspectRatio(boolean) : "Screen Aspect Ratio" : 0	
	fogEnable(boolean) : "Fog Enable?" : 0 : "Enable fog rendering in the camera."
	fogColor(color255) : "Fog Color" : "0 0 0" : "Set the fog color."
	fogStart(float) : "Fog Start" : 2048 : "The near fog plane."
	fogEnd(float) : "Fog End" : 4096 : "The far fog/clipping plane."
	fogMaxDensity(float) : "Fog Max Density [0..1]" : 1 : "The maximum fog density. 0 = no fog, 1 = full fog."

	spawnflags(Flags) =
	[
		1 : "Start Off" : 0 
	]
	
	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."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_clientcommand") = point_clientcommand : 
	"An entity that issues commands to the client console, as if it was typed in by the player (if activator is a player, or the local player in single player). "+
	"Most commands are blocked, to see a list of allowed commands, do 'findflags server_can_execute' in the developer console."
[
	input Command(string) : "Command to execute."
]

@PointClass base(BaseEntityPoint, EnableDisable) studioprop("models/extras/info_speech.mdl") = point_commentary_node : 
    "Core entity used in the Commentary System. It appears as a floating speech bubble for the player to +USE, which then starts the commentary playing. This entity is typically placed with the Commentary Editor."
[
	commentaryfile(sound) : "Commentary sound file" :  : "The commentary sound file that should be played when this node is used by the player."
	commentaryfile_nohdr(sound) : "Commentary sound NoHDR" :  : "The commentary sound file that should be played when this node is used by the player. If the player has HDR turned off, this file will be used instead of the commentaryfile. If this entry is not specified, the base commentaryfile entry will still be used."
	speakers(string) : "Speakers" : "Gabe Newell" : "The name of the speakers of the commentary sound file(s). Will be displayed in the HUD while the commentary sound file is playing."
	precommands(string) : "semi-colon delimited list" :  : "A semi-colon delimited list of commands that should entered into the console when the commentary file starts playing. e.g. ai_disable 1;mat_wireframe 1"
	postcommands(string) : "semi-colon delimited list" :  : "A semi-colon delimited list of commands that should entered into the console when the commentary file finishes playing. e.g. ai_disable 0;mat_wireframe 0"
	viewposition(target_destination) : "Players view move" :  : "The targetname of entity to which the players view should move while the commentary file is playing."
	viewtarget(target_destination) : "Players view track" :  : "The targetname of entity that the players view should track while the commentary file is playing."
	teleport_origin(string) : "Teleport To..." : "Teleport to this entity."
	prevent_movement(boolean) : "Prevent Movement?" : 0 : "If Yes, the player will not be able to move while the commentary sound file is playing"

	input StartCommentary(void) : "Force the commentary node to start."
	input StopCommentary(void) : "Force the commentary node to stop."
	input StartUnstoppableCommentary(void) : "Force the commentary node to start, and don't allow the player to stop it in any way."
	
	output OnCommentaryStarted(void) : "Sent when Commentary started."
	output OnCommentaryStopped(void) : "Sent when Commentary stopped."
	
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/camera.mdl") = point_devshot_camera : 
	"An entity used by the -makedevshots system, which automatically takes screenshots at the position of every point_devshot_camera in the level."
[
	cameraname(string) : "Camera Name" :  : "Used as the name of the directory to store screenshots from this camera. Must be set or screenshot-taking will fail. Must be unique within the level."
	FOV(integer) : "Camera FOV" : 75 : "FOV of this camera."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_enable_motion_fixup") = point_enable_motion_fixup : 
	"An entity used to move a motion-disabled prop when it enables motion. Parent this entity to the prop, and when the prop has its motion enabled, it will immediately teleport to the origin of this entity."
[
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_message") sphere(radius) = point_message : 
	"An entity that displays a text message in the world, at its origin."
[
	message(string) : "Entity Message" : : "Message to display."
	radius(integer) : "Radius" : 128 : "Distance the player must be within to see this message."
	developeronly(boolean) : "Developer Only?" : 0 : "If set, this message will only be visible when developer mode is on."
	
	spawnflags(flags) =
	[
		1: "Start Disabled?" : 0
	]

	input Enable(void) : "Start displaying the message text, if the player is within the message radius."
	input Disable(void) : "Stop displaying the message text."
]

@PointClass base(BaseEntityPoint) = point_entity_finder :
	"An entity that will find an entity and pass it along as the !Caller with the OutEntity output.  Requires using !Caller as the parameter on the input."
[
	filtername(filterclass) : "Filter Name" : : "Filter to use to narrow set of findable entities. See filter_activator_name for more explanation."
	referencename(target_destination) : "Reference Entity" : "" : "Name of the entity to use when evaluating criteria.  For example, when using 'Nearest', this is the entity that distance will be measured from.  If left blank will use the point_entity_finder."

	Method(choices) : "Search Method" : "0" =
	[
		0 : "Nearest"
		1 : "Farthest"
		2 : "Random"
	]

	input FindEntity(void) : "Find an entity that meets the specified criteria.  Will fire OutEntity if found and pass the entity as !Caller."

	output OnFoundEntity(void) : "Fired when FindEntity is input and an entity was found. Passes the found entity as !Caller."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_gamestats_counter") = point_gamestats_counter :
     "Generic game statistics counter."
[
	Name(string) 		: "Statistic Counter Name" : : "Name of statistic counter."

	input SetName(string)  : "Changes name of statistic counter"
	input Increment(float) : "Increments named statistic counter by specified value"
	input Enable(void) : "Enables the statistic counter."
	input Disable(void) : "Disable the statistic counter."
]

@PointClass base(BaseEntityPoint, DamageType) iconsprite("editor-ficool2/point_hurt") sphere(DamageRadius) = point_hurt :
	"An entity that does damage to all entities in a radius around itself, with a specified delay." +
	"If 'Target Entity' is specified, the damage is only done to that entity."
[
	DamageTarget(string) : "Target Entity" :  : "If specified, only this entity will take damage. Otherwise, all entities within the Radius will take damage. Can be set to damage the !activator."
	DamageRadius(float) : "Radius" : 256 : "All entities within this radius of this entity will take damage. If a 'Target Entity' is specified, only that entity will take damage."
	Damage(integer) : "Damage" : 5 : "Damage done to all affected entities each time this entity fires."
	DamageDelay(float) : "Delay" : 1 : "Delay between refires, in seconds."

	input Hurt(void) : "Force a single fire, damaging either the Target Entity or all entities within the radius."
	input TurnOn(void) : "Enable this entity. It will start damaging entities everytime it fires, and refire based upon the specified Delay."
	input TurnOff(void) : "Disable this entity. It will stop damaging entities."
	input Toggle(void) : "Toggle this entity between On/Off state."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_intermission") = point_intermission : 
    "Entity that ends the match and triggers an intermission."
[
	input Activate(void) : "Causes the game to end and the intermission to begin."
]


@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_playermoveconstraint") sphere(radius) = point_playermoveconstraint : 
	"An entity that constrains players to a radius around itself, slowing them down the closer they get to the edge of the radius."
[
	radius(float) : "Radius" : 256 : "Radius to constrain players to."
	width(float) : "Constraint Width" : "75.0" : "Width of the constraint edge. This is the distance in which to start slowing players down as they approach the edge of the radius."
	speedfactor(float) : "Speed Factor" : "0.15" : "Factor applied to the player's max speed as they approach the radius edge."

	input TurnOn(void) : "Start constraining any players within the radius."
	input TurnOff(void) : "Stop constraining any players previously constrained."

	output OnConstraintBroken(void) : "Fired when a player breaks through the constraint."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_posecontroller") = point_posecontroller : 
	"An entity that controls a pose parameter of a prop and cycles the pose clientside. Using an invalid or non-existant Pose Parameter will crash the game." 
[
	PropName(string) : "Prop Name" : : "Name of the prop to control."
	PoseParameterName(string) : "Pose Parameter Name" : : "Name of the pose parameter to control."
	PoseValue(float) : "Pose Parameter Value" : "0.0" : "Normalized value for the pose parameter from 0.0 and 1.0 (maps to min and max range). Suffers from rounding or overflow errors, the only fix is to constantly set a new value using SetPoseValue."
	InterpolationTime(float) : "Interpolation Time" : "0.0" : "Number of seconds (0.0 to 10.0) for client to match absolue pose values."
	InterpolationWrap(boolean) : "Interpolation Wrap?" : "0" : "Should wrap from 0.0 to 1.0 when interpolating."
	CycleFrequency(float) : "Cycle Frequency" : "0.0" : "Base cycles per second from -10.0 to 10.0."
	FModulationType(choices) : "Frequency Modulation Type" : 0 = 
	[
		0: "None"
		1: "Sine"
		2: "Square"
		3: "Triangle"
		4: "Sawtooth"
		5: "Noise"
	]
	FModTimeOffset(float) : "Frequency Modulation Time Offset" : "0.0" : "Modulation time offset from -1.0f to 1.0."
	FModRate(float) : "Frequency Modulation Rate" : "0.0" : "Modulation cycles per second from -10.0f to 10.0."
	FModAmplitude(float) : "Frequency Modulation Amplitude" : "0.0" : "Modulation extents from 0.0f to 10.0."
	
	input SetPoseParameterName(string) : "Sets the pose parameter to control."
	input SetPoseValue(float) : "Set the pose parameter to a normalized value between 0.0 and 1.0 (maps to min and max range)."
	input SetInterpolationTime(float) : "Set the interpolation time to a number of seconds between 0.0 and 10.0."
	input SetCycleFrequency(float) : "Set the pose parameter's base cycles per second from -10.0f to 10.0."
	input SetFModType(integer) : "Set the type of frequency modulation."
	input SetFModTimeOffset(float) : "Set the modulation time offset from -1.0f to 1.0."
	input SetFModRate(float) : "Set the modulation cycles per second from -10.0f to 10.0."
	input SetFModAmplitude(float) : "Set the modulation extents from 0.0f to 10.0."
	input RandomizeFMod(float) : "Randomize the frequency modulation by an extremeness of 0.0 to 1.0."
	input GetFMod(void) : "Outputs the current modulation settings in console to the activating player."
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/point_proximity_sensor") = point_proximity_sensor :
	"An entity that detects another entity's proximity to this entity."
[
	target(target_destination) : "Target Entity Name" : : "Name of the entity whose proximity will be sensed."

	spawnflags(Flags) =
	[
		1 : "Test the distance as measured along the axis specified by our direction." : 0
	]
	
	input Toggle(void) : "Toggle the sensor between enabled and disabled."
	input SetTargetEntity(string) : "Set the entity to detect."
	
	output Distance(float) : "Distance of the target entity away from this entity."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_push") sphere(radius) sphere(inner_radius) = point_push: 
    "Push sphere that will push any physics props or entity that has a movement type set (e.g. NPCs) away from its origin. Does not push parented objects."
[
	enabled(boolean) : "Start Enabled?"	: 1
	
	magnitude(float) : "Magnitude" : 100 : "How strongly to push away from the center. Negative values will pull into the centre."
	radius(float) : "Radius" : 128 : "Radius to affect items in."
	inner_radius(float) : "Inner radius" : "0" : "If not zero, the LOS is calculated from a point intersecting this sphere."
	
	spawnflags(Flags) = 
	[
		1 : "Test LOS before pushing" : 0
		2 : "Use angles for push direction" : 0
		4 : "No falloff (constant push at any distance)" : 0
		8 : "Push players" : 1
		16 : "Push physics" : 1
	]
	
	input Enable(void) : "Enable the push."
	input Disable(void): "Disable the push."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_servercommand") = point_servercommand : 
	"An entity that issues commands to the server console. Servers may block this entity with the sv_allow_point_servercommand convar or with plugins."
[
	input Command(string) : "Command to execute."
]

@PointClass base(BaseEntityPoint, Render) studioprop("models/editor-ficool2/cone_helper_blue.mdl") = point_spotlight : 
	"An entity to draw a spotlight. Will draw a beam when the player views it side on, and a halo when it's facing towards the player. "+
	"Unless the 'No Dynamic Light' spawnflag is checked, it will also create a dynamic light wherever the end of the spotlight rests."
[
	IgnoreSolid(boolean) : "Ignore Solids?" : 0 : "If set, this spotlight won't trace for solids."

	spotlightlength(integer) : "Spotlight Length" : 500 : "Length of the spotlight beam."
	spotlightwidth(integer) : "Spotlight Width" : 50 : "Width of the spotlight beam."
	rendercolor(color255) : "Color (R G B)" : "255 255 255" : "Spotlight color."
	HDRColorScale(float) : "HDR color scale." : "1.0" : "float value to multiply sprite color by when running in HDR mode."
	
	spawnflags(Flags) = 
	[
		1 :  "Start On" : 1
		2 :  "No Dynamic Light" : 1
	]
	
	input LightOn(void) : "Turn the spotlight on."
	input LightOff(void) : "Turn the spotlight off"
	
	output OnLightOn(void) : "Fires when light turns on."
	output OnLightOff(void) : "Fires when light turns off."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_teleport") = point_teleport : 
	"An entity that teleports a target entity to this position and angles. "+
	"If 'Teleport Home' spawn flag is set, teleports the target entity to its spawn position instead." +
	"If object is physically simulated, simulation is turned off when teleported. "+
	"The entity does not update its origin or angles ever, even after it has moved. Use trigger_teleport as a workaround if necessary."
[
	target(target_destination) : "Entity To Teleport" : : "Name of the entity that will be teleported."
	spawnflags(flags) =
	[
		1 : "Teleport Home" : 0
		2 : "Into Duck/Crouch)" : 0
	]

	input Teleport(void) : "Teleport the target entity."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/point_template") = point_template : 
	"Turns an entity, or set of entities, into a single template that can be instanced anywhere, and multiple times. "+
	"If there are interdependencies (entity I/O, hierarchy, or other name references) between the entities "+
	"in the template, the entities in the template will have their names changed and the interdependencies will "+
	"be reconnected to the changes names. The name change format is as follows: '<original name>&0000', where the 0000 "+
	"will be replaced with the current global template instance, so wildcard searches for '<original name>*' will still find them.\n"+
	"If you don't want the name fixup to happen, because you're only spawning the template once, or you want inputs to "+
	"trigger all instances of the template, check the 'Preserve entity names' spawnflag. \n"+
	"To spawn the template in other places, use an env_entity_maker."
[
	Template01(target_destination) : "Template 1"
	Template02(target_destination) : "Template 2"
	Template03(target_destination) : "Template 3"
	Template04(target_destination) : "Template 4"
	Template05(target_destination) : "Template 5"
	Template06(target_destination) : "Template 6"
	Template07(target_destination) : "Template 7"
	Template08(target_destination) : "Template 8"
	Template09(target_destination) : "Template 9"
	Template10(target_destination) : "Template 10"
	Template11(target_destination) : "Template 11"
	Template12(target_destination) : "Template 12"
	Template13(target_destination) : "Template 13"
	Template14(target_destination) : "Template 14"
	Template15(target_destination) : "Template 15"
	Template16(target_destination) : "Template 16"
	
	spawnflags(flags) =
	[
		1 : "Don't remove template entities" : 0
		2 : "Preserve entity names (Don't do name fixup)" : 1
	]

	input ForceSpawn(void) : "Spawn an instance of the template at the original position."
	
	output OnEntitySpawned(void) : "Fired after spawning an instance of this template."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_tesla") sphere(m_flRadius) = point_tesla : 
	"An entity that creates tesla lightning arcs around its origin."
[
	m_SourceEntityName(string) : "Source Entity" :  : "If specified, tesla lightning will originate from the specified entity. Otherwise, they originate from this entity."
	m_SoundName(sound) : "Sound Name" : "DoSpark" : "Sound to be played whenever lightning is created."

	texture(sprite) : "Sprite Name" : "sprites/physbeam.vmt" : "Material to use for the tesla lightning beams."
	m_Color(color255) : "Color" : "255 255 255" : "Beam color."

	m_flRadius(integer) : "Radius" : 200 : "Radius around the origin to find a point to strike with a tesla lightning beam."

	beamcount_min(integer) : "Min # of Beams" : 6 : "Minimum number of tesla lightning beams to create when creating an arc."
	beamcount_max(integer) : "Max # of Beams" : 8 : "Maximum number of tesla lightning beams to create when creating an arc."
	
	thick_min(string) : "Min Beam Width" : "4" : "Minimum width of the tesla lightning beams."
	thick_max(string) : "Max Beam Width" : "5" : "Maximum width of the tesla lightning beams."
	
	lifetime_min(string) : "Min Time Visible" : "0.3" : "Minimum lifetime of the tesla lightning beams."
	lifetime_max(string) : "Max Time Visible" : "0.3" : "Maximum lifetime of the tesla lightning beams."
	
	interval_min(string) : "Min Time Between Arcs":"0.5" : "Minimum time delay between random arcing."
	interval_max(string) : "Max Time Between Arcs":"2" : "Maximum time delay between random arcing."
	
	m_bOn(boolean) : "Start On?"	: 1 : "Start the point_tesla already on? Untested."

	input TurnOn(void) : "Turn the tesla on." 
	input TurnOff(void) : "Turn the tesla off."
	input DoSpark(void) : "Force a single arc."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/point_velocitysensor")  = point_velocitysensor :
	"An entity that detects and outputs an entity's velocity. The Velocity output is fired every frame, so use with caution!"
[
	target(target_destination) : "Target Entity Name" : : "Name of the entity whose velocity will be sensed."
	axis(vecline) : "Measurement Axis" : : "The axis to measure the velocity along with."
	enabled(boolean) : "Start Enabled?" : 1 : "Whether or not to start enabled and active."

	output Velocity(float) : "Fired when the Target's Velocity changes, passing the new magnitude of the velocity."

	input Enable(void) : "Enable the sensor."
	input Disable(void) : "Disable the sensor."
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/camera.mdl") = point_viewcontrol : 
	"A camera entity that controls the player's view. While it's active, the player will see out of the camera. "+
	"The camera doesn't follow its path correctly. It will not follow paths at all if it doesn't have an Entity to Look At set. "+
	"The camera ignores the New Train Speed keyvalue and Teleport to THIS path_corner spawnflag on path_tracks. "+
	"The camera fails to function when parented, logic_measure_movement can be used as a workaround."+
	"If the camera is killed while active, or the player suicides, the camera view will be stuck permanently on the player's screen. The only fix afterwards is for the player to reconnect to the server."
[
	target(target_destination) : "Entity to Look At" : : "Name of the entity that the camera should point at and track while active."
	targetattachment(string) : "Target Attachment Name" : : "If set, the camera will focus on the specified attachment on the 'Entity to Look At'."
	wait(integer) : "Hold Time" : 10 : "The amount of time the camera should control the player's view for, after which it deactivates itself. If the camera should stay active until told to deactive, set the 'Infinite Hold Time' spawnflag."
	moveto(target_destination) : "First path_corner" : : "The first path_corner in a track that the camera should move along once it's activated. If not specified, the camera won't move."
	speed(string) : "Initial Speed" : "0" : "The starting speed that the camera moves at, if it's on a path track."
	acceleration(string) : "Acceleration units/sec^2" : "500" : "The speed at which the camera accelerates to path corner's desired speeds."
	deceleration(string) : "Stop Deceleration units/sec^2" : "500" : "The speed at which the camera decelerates to path corner's desired speeds."
	fov(float) : "FOV" : "90" : "The FOV when using this camera."
	fov_rate(float) : "FOV rate" : "1" : "How fast we change to the new fov."
	
	spawnflags(flags) =
	[
		1:   "Start At Player - Start the camera at the player's position. Breaks if the player was moving when activating." : 0
		2:   "Follow Player - This is the same as if you set the lookat target to !player. Causes issues in multiplayer." : 0
		4:   "Freeze Player - Stop recognizing input from the player." : 1
		8:   "Infinite Hold Time - Ignore the hold time, and stay activated until explicitly disabled." : 0
		16:  "Snap to goal angles" : 0
		32:  "Make Player non-solid" : 0
		64:  "Interruptable by Player - If the player presses +Use, disable." : 0
		128: "Set FOV" : 0
	]

	input Enable(void) : "Enable the point_viewcontrol, and start controlling the player's view."
	input Disable(void) : "Disable the point_viewcontrol, and stop controlling the player's view."

	output OnEndFollow(void) : "Fired when the point_viewcontrol deactivates, due to the Disable input being received, the Entity to Look At being destroyed, or the Hold Time expiring."
]

@PointClass studioprop() = prop_detail : 
	"Used to manually create a detail prop. It only supports model detail props."
[
	model(studio) : "Model" : : "The model to appear as. Must be compiled with $staticprop and use UnlitGeneric shaders on every material. Maximum string length is 128."
    origin(origin) : "Origin (X Y Z)" : : "The position of this entity's center in the world. Rotating entities typically rotate around their origin."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."
]

@PointClass iconsprite("editor-ficool2/prop_detail_sprite") = prop_detail_sprite : 
	"Allows the manual insertion of detail sprites into a level."
[
	origin(origin) : "Origin (X Y Z)" : : "The position of the sprite."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This sprite's orientation in the world."
	detailOrientation(choices) : "Detail Orientation" : "2" : "How the sprite will react to the camera." =
	[
		"0" : "It will not rotate."
		"1" : "It will rotate around its origin to always face the camera head-on."
		"2" : "It will rotate around its Z-axis only to face the camera."
	]
	
	position_ul(vector) : "Upper Left Position" : : "Location of the sprite's upper left corner, relative to the origin."
	position_lr(vector) : "Lower Right Position" : : "Location of the sprite's lower right corner, relative to the origin."
	tex_ul(vector) : "Upper Left Texture" : : ""
	tex_size(vector) : "Texture Size" : : ""
	tex_total_size(float) : "Total Texture Size" : : "The area of the detail texture that should constitute this sprite."
]

// Why is it associated with prop_dynamic in code if the door requires to be compiled as a physically-simulated object???
@PointClass base(prop_dynamic_base) studioprop() = prop_door_rotating : 
	"An entity used to place a door in the world."
[
	slavename(target_destination) : "Slave Name" : : "The name of any doors that should be slaved to this door (i.e. should open when this one opens, and close when this one closes)."
	hardware(choices) : "Hardware Type" : 1 : "The type of mechanism used to open the door (handle, push bar, keypad). The mechanism only appears in the game, not in Hammer. " =
	[
		0 : "<None>"
		1 : "Lever (i.e. door handle)"
		2 : "Push bar"
		3 : "Keypad"
	]
	
	ajarangles(angle) : "Ajar Angles (Pitch Yaw Roll)" : "0 0 0" : "If the door 'Spawn Position' is set to Ajar, these are the angles to spawn at, instead of being open or closed."
	spawnpos(choices) : "Spawn Position" : 0 : "State the door should begin in. Check the door's angles to see forward/backward orientation." =
	[
		0 : "Closed"
		1 : "Open forward"
		2 : "Open back"
		3 : "Ajar (use Ajar Angles)"
	]
	
	axis(axis) : "Hinge Axis" : : "Axis around which to rotate when the door is opened. Despite Hinge Axis values, the door can only rotate on the Z Axis?"
	distance(float) : "Rotation Distance (deg)" : 90 : "Number of degrees that the door should open, both forward and backward."
	speed(integer) : "Speed" : 100 : "The speed at which the door moves, in degrees/second."
	soundopenoverride(sound) : "Fully Open Sound" : : "Sound played when the door has finished opening."
	soundcloseoverride(sound) : "Fully Closed Sound" : : "Sound played when the door has finished closing."
	soundmoveoverride(sound) : "Moving Sound" : : "Sound played when the door starts to move."
	soundlockedoverride(sound) : "Locked Sound" : : "Sound played when the player tries to open the door, and fails because it's locked."
	soundunlockedoverride(sound) : "Unlocked Sound" : : "Sound played when the door is unlocked."
	returndelay(integer) : "Delay Before close (-1 stay open)" : -1 : "Amount of time, in seconds, after the door has opened before it closes. If the value is set to -1, the door never closes itself."
	dmg(integer) : "Damage Inflicted When Blocked" : 0 : "Amount of damage done to entities that block the movement of this door, per frame."
	health(integer) : "Door Health" : 0 : "The health of the door (allows someone to shoot it open). 0 means invincible."
	forceclosed(boolean) : "Force Closed?" : 0 : "If set, this door will close no matter what. Useful for doors that have to close even if the player tries to block them with objects."

	opendir(choices) : "Open Direction" : 0 : "Force the door to open only forwards or only backwards. Both directions is the standard door behavior." =
	[
		0 : "Open Both Directions"
		1 : "Open Forward Only"
		2 : "Open Backward Only"
	]
	
	spawnflags(flags) =
	[
		1 : "Starts Open" : 0
		4 : "Don't Link" : 0
		8: "Passable" : 0
    	32: "Toggle" : 0
		256: "Use Opens" : 0
		512: "NPCs can't Use" : 0
		1024: "Touch Opens " : 0
		2048: "Starts Locked" : 0
		4096: "Door Silent (No sound, and does not alert NPCs)" : 0
		8192: "Use Closes" : 1
		16384 : "Door silent to NPCS (Does not alert NPCs)" : 0
		32768 : "Ignore player +USE" : 0
		524288 : "Start Unbreakable" : 0
	]

	output OnClose(void) : "Fired when the door is told to close."
	output OnOpen(void) : "Fired when the door is told to open."
	output OnFullyOpen(void) : "Fired when the door reaches the fully open position."
	output OnFullyClosed(void) : "Fired when the door reaches the fully closed position."
	output OnBlockedClosing(void) : "Fired when the door is blocked while closing."
	output OnBlockedOpening(void) : "Fired when the door is blocked while opening."
	output OnUnblockedClosing(void) : "Fired when the door is unblocked while closing."
	output OnUnblockedOpening(void) : "Fired when the door is unblocked while opening."
	output OnLockedUse(void) : "Fired when the player uses the door, but it is locked."

	input Open(void) : "Open the door, if it is not fully open."
	input OpenAwayFrom(string) : "Open the door away from the specified entity."
	input Close(void) : "Close the door, if it is not fully closed."
	input Toggle(void) : "Toggle the door between open and closed."
	input Lock(void) : "Lock the door."
	input Unlock(void) : "Unlock the door."
	input SetRotationDistance(float) : "Set the distance (in degrees) between Open and Closed."
	input SetSpeed(float) : "Set the speed at which the door rotates. 100 is default."
]

@PointClass base(prop_dynamic_base) studioprop() = prop_dynamic :
	"A prop that can be placed in hierarchy and can play animations. It can also be configured to break when it takes enough damage. "+
	"Note that the health of the object will be overridden by the health inside the model, to ensure consistent health game-wide. "+
	"If the model used by the prop is configured to be used as a prop_physics (i.e. it should be physically simulated) then it CANNOT be "+
	"used as a prop_dynamic, use prop_dynamic_override if you really need to use a prop_physics for this entity."
[
]

@PointClass base(prop_dynamic_base) studioprop() = prop_dynamic_ornament :
	"Identical to prop_dynamic but has bonemerge flags automatically set."
[
	InitialOwner(string) : "Target Entity" : : "Name of the entity that this ornament should attach to, at startup."
	
	input SetAttached(string) : "Attach the ornament to a different entity. Parameter should be the name of entity to attach to."
	input Detach(string) : "Detach from the Target Entity and become invisible. The ornament can be re-attached with the SetAttached input."
]

@PointClass base(prop_dynamic_base) studioprop() = prop_dynamic_override :
	"Identical to prop_dynamic, but allows the use of models designed to be used as prop_physics."
[
	health(integer) : "Health" : 0 : "Number of points of damage to take before breaking. 0 means don't break."	
]

@PointClass base(BaseAnimatingPhysics, BreakableProp) sphere(exploderadius) studioprop() = prop_physics :
	"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. "+
	"Note that the health of the object will be overridden by the health inside the model, to ensure consistent health game-wide. "+
	"If the model used by the prop is configured to be used as a prop_dynamic (i.e. it should not be physically simulated) then it CANNOT be "+
	"used as a prop_physics. If you really need to use it as prop_physics, use a prop_physics_override."
[
	minhealthdmg(integer) : "Min Damage to Hurt" : 0 : "The prop will ignore any damage events if the damage is less than this amount."
	shadowcastdist(integer) : "Shadow Cast Distance" : : "Use this to override how far this object casts shadows. 0 = default distance."
	physdamagescale(float) : "Physics Impact Damage Scale" : "0.1" : "Scales damage energy when this object is hit by a physics object. NOTE: 0 means this feature is disabled for backwards compatibility.\nSet to 1.0 for materials as strong as flesh, smaller numbers indicate stronger materials."
	Damagetype(choices) : "Impact damage type" : 0 : "If set to Sharp, damage is more 'sharper' and the object can slice others." =
	[
		0: "Blunt"
		1: "Sharp"
	]

	nodamageforces(boolean) : "Damaging it Doesn't Push It?" : 0 : "Used to determine whether or not damage should cause the brush to move."

	inertiaScale(float) : "Scale Factor For Inertia" : "1.0" : "Scales the angular mass of an object. Used to hack angular damage and collision response."
	massScale(float) : "Mass Scale" : "0" : "A scale multiplier for the object's mass."
	overridescript(string) : "Override Parameters" :  : "A list of physics key/value pairs that are usually in a physics prop .qc file. Format is 'key,value,key,value,etc'."
	damagetoenablemotion(integer) : "Health Level to Override Motion" : 0 : "If specified, this object will start motion disabled. Once its health has dropped below this specified amount, it will enable motion."
	forcetoenablemotion(float) : "Physics Impact Force to Override Motion" : 0 : "If specified, this object will start motion disabled. Any impact that imparts a force greater than this value on the physbox will enable motion."
	puntsound(sound) : "Sound to make when punted."
	
	spawnflags(flags) = 
	[
		1 : "Start Asleep" : 1
		2 : "Don't take physics damage" : 0
		4 : "Debris - Don't collide with the player or other debris" : 0
		8 : "Motion Disabled" : 0
		64 : "Enable motion on Physcannon grab" : 0
		128 : "Not affected by rotor wash" : 0
		256 : "Generate output on +USE " : 1
		512 : "Prevent pickup" : 0
		1024: "Prevent motion enable on player bump" : 0
		4096: "Debris with trigger interaction" : 0
		8192: "Force server-side (Multiplayer only)" : 0
		1048576: "Physgun can always pick up. No matter what." : 0
	]
	
	input Wake(void) : "Wake up this physics object, if it is sleeping."
	input Sleep(void) : "Put this physics object to sleep. It will wake if given the Wake input, or if force is applied to it. Note that physics objects go to sleep automatically after coming to rest for a while, so you don't really need to use this."
	input EnableMotion(void) : "Enable physics motion/collision response."
	input DisableMotion(void) : "Disable physics motion/collision response."
	input DisableFloating(void) : "Disable fluid/floating simulation to reduce cost."
	input SetBodyGroup(integer) : "Set this prop's body group (from 0 - n)."
	input physdamagescale(float) : "Set the Physics Impact Damage Scale for this character. NOTE: 0 means this feature is disabled for backwards compatibility."
	input EnableDamageForces(void) : "Damaging the entity applies physics forces to it."
	input DisableDamageForces(void) : "Damaging the entity does *not* apply physics forces to it."
	input EnablePuntSound(void) : "Allow this prop to play its own sound when punted."
	input DisablePuntSound(void) : "Prevent this prop from playing its own sound when punted."

	output OnMotionEnabled(void) : "Fired when motion is enabled on this prop, either via 'Health Level to Override Motion' or from the EnableMotion input."
	output OnAwakened(void) : "Fired when this entity becomes awake (collision/force is applied to it while it's asleep)."
	output OnPhysGunPickup(void) : "Fired when the player picks up the prop with the physcannon or +USE."
	output OnPhysGunPunt(void) : "Fired when a player punts this object with the physcannon."
	output OnPhysGunOnlyPickup(void) : "Fired when a player picks this object up with the physcannon. +USE pickups do not fire this output."
	output OnPhysGunDrop(void) : "Fired when the player drops the prop with the physcannon or USE."
	output OnPlayerUse(void) : "Fired when the player tries to +USE the prop. This output will fire only if the Generate output on +USE spawnflag is set."
	output OnPlayerPickup(void) : "Fired whenever the player picks up this prop (with the physcannon or with +USE)."
	output OnOutOfWorld(void) : "Fired whenever the prop is out of the allowed world bounds."
]

@PointClass base(prop_physics) studioprop() = prop_physics_multiplayer :
	"This class is the same as prop_physics, except the runtime collisions use a more bouncy method that avoids the prediction errors normal physics objects get."
[
	physicsmode(choices) : "Physics Mode" : 0 : "Change the physics mode of this entity." =
	[
		0: "Auto Detect"
		1: "Solid, Server-side"
		2: "Non-Solid, Server-side"
		3: "Non-Solid, Client-side"
	]
]

@PointClass base(prop_physics) studioprop() = prop_physics_override :
	"Identical to prop_physics, but allows models not compiled for physical simulation usually to be used."
[
	health(integer) : "Health" : 0 : "Number of points of damage to take before breaking.  0 means don't break."
]

@PointClass base(prop_physics) studioprop() = prop_physics_respawnable :
	"Identical to prop_physics, except it respawns after breaking."
[
	RespawnTime(float) : "Respawn Time" : 60 : "Amount of time this prop will respawn after it breaks, in seconds."
]

@PointClass base(BaseAnimatingPhysics, EnableDisable) studioprop() = prop_ragdoll :
	"A prop that physically simulates and can be articulated with internal joints. The joint constraints are part of the physics model. Very expensive to simulate."
[
	angleOverride(string) : "Override Animation" :  : "Filled in by the engine via hammer_update_entity, do not edit by hand except to clear."
	sequence(integer) : "Sequence" : : "Animation sequence to spawn the ragdoll in, by index NOT name!"

	spawnflags(flags) = 
	[
		4 : "Debris - Don't collide with the player or other debris (better performance)" : 1
		8192 : "Allow Dissolve" : 1
		16384 : "Motion Disabled" : 0
		32768 : "Allow stretch" : 0
		65536 : "Start asleep" : 0
	]
	
	input StartRagdollBoogie(void) : "Begins ragdoll boogie effect. Parameter override = number of seconds to boogie."
	input EnableMotion(void) : "Enable physics motion/collision response."
	input DisableMotion(void) : "Disable physics motion/collision response."
	input FadeAndRemove(float) : "Fade out then remove self. Parameter override = duration of fade"
]

@PointClass base(BaseAnimating) studioprop() = prop_scalable :
    "Scalable Prop"
[
	input SetScaleX(vector) : "Scales the prop in one Axis. Params: <New Size> <Time>"
	input SetScaleY(vector) : "Scales the prop in one Axis. Params: <New Size> <Time>"
	input SetScaleZ(vector) : "Scales the prop in one Axis. Params: <New Size> <Time>"
]

@PointClass base(prop_physics) sphere(radiushelper) studioprop() = prop_sphere : 
    "Creates a perfect sphere collision mesh of radius 12 units for a model."
[
	radiushelper(integer) readonly : "Hammer Radius Helper" : 24 : "Helper keyvalue to show the collision mesh size."
]

@PointClass color(255 255 0) sphere(fademindist) sphere(fademaxdist) studioprop() = prop_static :
	"A prop that doesn't move and doesn't animate, essentially being part of the map geometry."
[
	model(studio) :"Model" : : "The model to appear as. Models with $bumpmapped materials are never lit per-vertex."
    angles(angle) : "Pitch Yaw Roll (X Y Z)" : "0 0 0" : "This entity's orientation in the world. Roll is the rotation around the X axis, pitch is rotation around the Y axis and yaw is the rotation around the Z axis."
	skin(integer) : "Skin" : 0 : "Some models have multiple versions of their textures, called skins. Set this to a number other than 0 to use that skin instead of the default."
	solid(choices) : "Collisions" : 6 : "The method of collision to use for the prop." =
	[
		"": "< Default >"
		0: "None"
		1: "BSP (QPhysics)"
		2: "Bounding Box"
		3: "Oriented Bounding Box"
		4: "Oriented Bounding Box, constrained to Yaw only"
		5: "Custom (defined per-entity, if not defined the entity will have bizarre collision behavior)"
		6: "VPhysics"
	]
	mindxlevel(choices) : "Minimum DirectX Level" : 0 = 
	[
		0 : "Default (lowest)"
		60 : "DirectX 6.0"	
		70 : "DirectX 7.0"
		80 : "DirectX 8.0 (4600Ti)"
		81 : "DirectX 8.1 (FX5200)"
		90 : "DirectX 9.0 SM2.0"
		95 : "DirectX 9.5 SM3.0"
		100 : "DirectX 10.0"
	]
	maxdxlevel(choices) : "Maximum DirectX Level" : 0 = 
	[
		0 : "Default (lowest)"
		60 : "DirectX 6.0"	
		70 : "DirectX 7.0"
		80 : "DirectX 8.0 (4600Ti)"
		81 : "DirectX 8.1 (FX5200)"
		90 : "DirectX 9.0 SM2.0"
		95 : "DirectX 9.5 SM3.0"
		100 : "DirectX 10.0"
	]
	screenspacefade(boolean) : "Screen Space Fade?" : 0 : "If enabled, the prop will fade out based on how many screen pixels it covers. The start and end fade distances come to represent the pixels that the prop covers at the start and end of its fade when this is enabled."
	fademindist(float) : "Start Fade Dist/Pixels" : -1 : "Distance at which the prop starts to fade (<0 = use fademaxdist). If 'Screen Space Fade' is selected, this represents the number of pixels wide covered by the prop when it starts to fade."
	fademaxdist(float) : "End Fade Dist/Pixels" : 0 : "Maximum distance at which the prop is visible (0 = don't fade out). If 'Screen Space Fade' is selected, this represents the *minimum* number of pixels wide covered by the prop when it fades."
	fadescale(float) : "Fade Scale" : 1 : "If you specify a fade in the worldspawn, or if the engine is running under DirectX 8, then the engine will forcibly fade out props even if fademindist/fademaxdist isn't specified." +
												 " This scale factor gives you some control over the fade. Using 0 here turns off the forcible fades." +
												 " Numbers smaller than 1 cause the prop to fade out at further distances, and greater than 1 cause it to fade out at closer distances."
	lightingorigin(target_destination) : "Lighting Origin" :  : "An info_lighting from which to sample lighting (instead of the model's origin). Disables per-vertex lighting."
	disableshadows(boolean) : "Disable Shadows?" : 0 : "Disable the prop from casting lightmap shadows."
	disablevertexlighting(boolean) : "Disable Vertex lighting?" : 0 : "Prop will be lit uniformly with a lighting value sampled from its origin if set to Yes."
	disableselfshadowing(boolean) : "Disable Self-Shadowing with vertex lighting?" : 0 : "Prop will not cast shadows on itself when per-vertex lighting is calculated." 
	ignorenormals(boolean) : "Ignore surface normal for computing vertex lighting?" : 0 : "A surface normal defines the direction from which each polygon is brightest-lit, and how much light is received. Setting this to Yes will ignore the surface normal. Great for foilage."
	generatelightmaps(boolean) : "Generate (and use) lightmaps for this static prop?" : 0 : "See http://forums.tf2maps.net/showthread.php?t=23288"
	lightmapresolutionx(integer) : "Lightmap Resolution X" : 32 : "The resolution of the generated lightmap in the X (or U) direction (only used if Generate Lightmaps is Yes)"
	lightmapresolutiony(integer) : "Lightmap Resolution Y" : 32 : "The resolution of the generated lightmap in the Y (or V) direction (only used if Generate Lightmaps is Yes)"
]

@PointClass base(BaseVehicle) studioprop() = prop_vehicle :
	"Vehicle that can be driven via inputs."
[
]

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

@PointClass base(BaseEntity, Angles) iconsprite("editor-ficool2/shadow_control") = shadow_control : 
	"An entity to control the shadows in the map."
[
	direction(vector) : "Shadow Direction" : : "Set the shadow direction. Duplicated with Angles for whatever reason, so change both."
	angles(angle) : "Pitch Yaw Roll (X Y Z)" : "80 30 0" : "This is the shadow direction. roll is the rotation around the X axis, Pitch is rotation around the Y axis, yaw is the rotation around the Z axis."
	color(color255) : "Shadow Color" : "128 128 128" : "This is the color of the shadows."
	distance(float) : "Maximum Distance" : 75 : "This is the maximum distance the shadow is allowed to cast, in units. Maximum is 4096."
	disableallshadows(boolean) : "All Shadows Disabled?" : 0 : "Disable shadows entirely."
	
	input color(color255) : "Set the shadow color."
	input direction(vector) : "Set the shadow direction. Duplicated with SetAngles for whatever reason, so set both."
	input SetDistance(float) : "Set the maximum shadow cast distance."
	input SetAngles(string) : "Set the shadow direction."
	input SetShadowsDisabled(integer) : "Set shadows disabled state."
]

// removed iconsprite due to scale keyvalue affecting the sprite and making it massive
@PointClass base(BaseEntity, Angles) size(-16 -16 -16, 16 16 16) color(0 0 255) = sky_camera : 
	"An entity used to control the 3D Skybox. Its origin is used to determine the 3D Skybox's position relative to the map. Place this entity, in the 3D Skybox, at the point where the origin of the map should be. "+
	"Multiple or moving 3D skyboxes can be done with this hacky workaround: https://tf2maps.net/threads/multiple-3d-skyboxes.35829/"
[
	scale(integer) : "3D Skybox scale" : 16 : "This number determines how large objects in your skybox will seem relative to the map. Take a skybox scale of 16, an object 1 unit high in the skybox will seem to be 16 units high to player."
	fogenable(boolean) : "Fog Enable?" : 0 : "Enable or disable the fog by default."
	fogblend(boolean) : "Fog Blend?" : 0 : "Enables color blending between Primary Fog Color and Secondary Fog Color. When the viewer looks in the Primary Fog Direction, fog will appear as the Primary color. When looking away from the specified direction, fog appears as the Secondary color. If the camera is not pointed directly at or away from the direction, a blend of the two colors will result. Sunlight with a Yaw of 45 degrees and a Pitch of -45 degrees could be enhanced using a Primary Fog Direction of '-1 -1 1', a Primary Fog Color of '120 110 100' and a Secondary Fog Color of '80 70 60'." 
	use_angles(boolean) : "Use Angles for Fog Direction?" : 0 : "Use Pitch Yaw Roll for the Fog Blend direction instead of Primary Fog Direction. There isn't much use for this unless you want the direction to rotate."
	fogcolor(color255) : "Primary Fog Color" : "255 255 255" : "Primary Fog Color."
	fogcolor2(color255) : "Secondary Fog Color" : "255 255 255" : "Secondary Fog Color. If Fog Blend is disabled, this color will never appear."
	fogdir(vector) : "Primary Fog Direction" : "1 0 0" : "A vector (given by three space-separated numbers X Y Z) which points from the secondary fog color fogcolor2 towards the primary fog color fogcolor."
	fogstart(string) : "Fog Start" : "500.0" : "Distance at which the fog should start."
	fogend(string) : "Fog End" : "2000.0" : "Distance at which the fog should be fully opaque."
	fogmaxdensity(float) : "Fog Max Density" : "1" : "Maximum density of the fog. [0..1] "
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/env_texturetoggle") = skybox_swapper :
	"An entity to control the skybox texture in a map."
[
	SkyboxName(string) : "Skybox Material" : "sky_tf2_04" : "Skybox material name you want to change to. Full directory and extension not needed."
	
	input Trigger(void) : "Change skybox texture."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/spark_shower") = spark_shower : 
	"Creates a trail of sparks in a random 60 degree spread from its angles. This entity will delete itself after creating the effect upon spawning."
[
]

@PointClass base(BaseAnimating) studioprop("models/effects/cappoint_hologram.mdl") = team_control_point :
	"Designates the location of a capture point; use in conjunction with trigger_capture_area. There is a maximum of 8 control points per map."
[
	point_start_locked(choices) : "Start Locked?" : 0 : "Locked means the point will not be available for capture until it is unlocked via its input."  =
	[
		0 : "No"
		1 : "Yes"
	]
	
	StartDisabled(choices) : "Start Disabled?" : 0 =
	[
		0 : "No"
		1 : "Yes"
	]

	point_printname(string) : "Print Name" :  : "LOCALIZED name to print on the HUD." 
	point_group(integer) : "Group Index" : 0 : "Used for grouping points together under a team_control_point_master (not using control point rounds)."
	point_default_owner(choices) : "Default Owner" : 0 : "Default Owner of the control point."  =
	[
		0 : "Neither"
		2 : "Red"
		3 : "Blue"
		4 : "Mercenary"
	]
	point_index(integer) : "Index" : 0 : "Index of this point (must be unique)."
	
	point_warn_on_cap(choices) : "Warning Type" : 0 : "Type of warning to issue to the team that owns the control point when the opposing team starts to capture it."  =
	[
		0 : "Normal Announcements"
		1 : "Final Capture Point Warning"
		2 : "No Announcements"
	]
	
	point_warn_sound(sound) : "Warning Sound" : "ControlPoint.CaptureWarn" : "Sound to be played when this point is being captured (if warn on capture is set)." 
	
	point_dom_score_amount(integer) : "Domination Score Amount" : 1 : "How much score this point awards to the owning team in Domination every few seconds."
	
	random_owner_on_restart(boolean) : "Randomly set the owner on restart?" : 0 : "Randomly set the owner of this point during a full restart of the map. The ratio of default owners among the points with this flag will be kept when selecting random owners." 
	point_capture_start_sound(sound) : "Start Capture Sound" :  : "The sound to play when the point starts being captured."
	point_capture_end_sound(sound) : "End Capture Sound" :  : "The sound to play when the point ends being captured."
	point_capture_progress_sound(sound) : "Capture Progress Sound" :  : "The sound to play when the point is progressing towards capture."
	point_capture_interrupted_sound(sound) : "Capture Interrupted Sound" :  : "The sound to play when the point's capture is interrupted."
	
	team_timedpoints_2(integer) : "Time-based point value for RED." : 0
	team_timedpoints_3(integer) : "Time-based point value for BLUE." : 0
	
	team_capsound_0(sound) : "Reset Sound" :  : "Sound made when point resets."
	team_capsound_2(sound) : "Red Capture Sound" :  : "Sound made when RED captures."
	team_capsound_3(sound) : "Blue Capture Sound" :  : "Sound made when BLUE captures."
	
	team_model_0(studio) 	: "Reset Model" : "models/effects/cappoint_hologram.mdl" : "Model when point is unowned."
	team_model_2(studio) 	: "RED Model" : "models/effects/cappoint_hologram.mdl" : "Model when RED owns the point."
	team_model_3(studio) 	: "BLUE Model" : "models/effects/cappoint_hologram.mdl" : "Model when BLUE owns the point."
	
	team_bodygroup_0(integer) : "Reset model bodygroup" : 3
	team_bodygroup_2(integer) : "RED model bodygroup" : 1
	team_bodygroup_3(integer) : "BLUE model bodygroup" : 1

	team_icon_0(material)	: "HUD icon neutral" : "sprites/obj_icons/icon_obj_neutral" : "HUD icon material when no one owns the point."
	team_icon_2(material)	: "HUD icon RED" : "sprites/obj_icons/icon_obj_red" : "HUD icon material when RED owns the point."
	team_icon_3(material)	: "HUD icon BLUE" : "sprites/obj_icons/icon_obj_blu" : "HUD icon material when BLUE owns the point."

	team_overlay_0(material) : "HUD overlay neutral" :  : "HUD material that will overlay the icon when no one owns the point."
	team_overlay_2(material) : "HUD overlay RED" :  : "HUD material that will overlay the icon when RED owns the point."
	team_overlay_3(material) : "HUD overlay BLUE" :  : "HUD material that will overlay the icon when BLUE owns the point."

 	team_previouspoint_2_0(target_source) : "RED Previous Required Point 1" :  : "The name of a previous capture point that RED must own to be able to capture this point. If empty, the team must own all points preceding this one. Pointing to itself means no previous point required."
	team_previouspoint_2_1(target_source) : "RED Previous Required Point 2" :  : "The name of a second previous capture point that RED must own to be able to capture this point."
	team_previouspoint_2_2(target_source) : "RED Previous Required Point 3" :  : "The name of a third previous capture point that RED must own to be able to capture this point."
	team_previouspoint_3_0(target_source) : "BLUE Previous Required Point 1" :  : "The name of a previous capture point that BLUE must own to be able to capture this point. If empty, the team must own all points preceding this one. Pointing to itself means no previous point required."
	team_previouspoint_3_1(target_source) : "BLUE Previous Required Point 2" :  : "The name of a second previous capture point that BLUE must own to be able to capture this point."
	team_previouspoint_3_2(target_source) : "BLUE Previous Required Point 3" :  : "The name of a third previous capture point that BLUE must own to be able to capture this point."

	spawnflags(flags) =
	[
		1: "Hide Control Point on HUD" : 0
		2: "Start with model hidden" : 0
		4: "Disable shadow" : 1
		8: "Disable sounds" : 0
	]

	input SetOwner(integer) : "Set the owner of the point."
	input HideModel(void) : "Hide the control point model."
	input ShowModel(void) : "Show the control point model again."
	input SetLocked(integer) : "Lock the control point. 0 = unlocked, 1 = locked"
	input SetUnlockTime(integer) : "This will automatically unlock the control point in the specified amound of time (seconds)."
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
	
	output OnOwnerChangedToTeam1(void) : "Sent when owner is changed to RED."
	output OnOwnerChangedToTeam2(void) : "Sent when owner is changed to BLUE."
	output OnCapReset(void) : "Sent when owner is changed to neutral."

	output OnRoundStartOwnedByTeam1(void) : "Sent when a round is starting and the point is owned by RED."
	output OnRoundStartOwnedByTeam2(void) : "Sent when a round is starting and the point is owned by BLUE."
	
	output OnCapTeam1(void) : "Sent when RED capture this point."
	output OnCapTeam2(void) : "Sent when BLUE capture this point."

	output OnUnlocked(void) : "Sent when point unlocks."
]

@PointClass base(BaseEntityPoint, EnableDisable) iconsprite("editor-ficool2/team_control_point_master") = team_control_point_master :
    "his entity controls all the control points in a map. It is responsible for the layout of the hud icons as well as some round specific settings. team_control_point_round entities will override settings if they are used. "
[
	team_base_icon_2(material) : "Material for the RED Base icon" : "sprites/obj_icons/icon_base_red"
	team_base_icon_3(material) : "Material for the BLUE Base icon" : "sprites/obj_icons/icon_base_blu"
	caplayout(string) : "Cap Layout" :  : "A string that tells the HUD how to lay out the cap points. It should be a string with indexes of cap points seperated by commas to denote a new line. So <2,0 1> would create a pyramid, with cap point 2 on the top and cap points 0 & 1 on the bottom."
	custom_position_x(float) : "Custom cap position X" : -1 : "Set the cap layout custom X position [0,1]"
	custom_position_y(float) : "Custom cap position Y" : -1 : "Set the cap layout custom Y position [0,1]"

	cpm_restrict_team_cap_win(choices) : "Restrict team from winning" : 0 : "Prevent this team from winning by capping all the points. This field is ignored if you're using control_point_rounds in your map (set this field inside the rounds)." =
	[
		0 : "Neither"
		1 : "Both"
		2 : "Red"
		3 : "Blue"
		4 : "Mercenary"
	]
	
	switch_teams(boolean) : "Switch teams on map win?" : 0 : "Switch the teams when one team has won the map and the game is going to be reset."
	
	score_style(choices) : "Scoring style" : 0 : "Sets the style of scoring used for capture point maps." = 
	[
		0 : "Add team score for each round won"
		1 : "Add team score for each captured point"
	]
	
	play_all_rounds(choices) : "Play all rounds before changelevel?" : 0 : "Determines whether the server may changelevel when mp_timelimit is up before all mini-rounds have been completed (for maps like Dustbowl)." = 
	[
		0 : "Changelevel normally"
		1 : "Only changelevel after all mini-rounds have been played to completion"
	]	
	
	partial_cap_points_rate(float) : "Partial cap rate" : 0 : "Rate at which to give partial cap points for area captures."

	
	input SetWinner(integer) : "Set the winner of the round to this team (0 for a stalemate)."
	input SetWinnerAndForceCaps(integer) : "Set the winner of the round to this team and give them ownership of all points."
	input SetCapLayout(string) : "Set the cap layout string."
	input SetCapLayoutCustomPositionX(float) : "Set the cap layout custom X position [0,1]"
	input SetCapLayoutCustomPositionY(float) : "Set the cap layout custom Y position [0,1]"
	input RoundSpawn(void) : "Forces this entity to spawn. Fired automatically at the start of a round."
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
	
	output OnWonByTeam1(void) : "Sent when RED wins the game."
	output OnWonByTeam2(void) : "Sent when BLUE wins the game."
]

@PointClass base(BaseEntityPoint,EnableDisable) iconsprite("editor-ficool2/team_control_point_round") = team_control_point_round :
	"Control Point Round (you may have as many of these in the map as you would like)."
[
	cpr_printname(string) : "Print Name" :  : "LOCALIZED name to print on the RoundInfo panel" 
	
	cpr_priority(integer) : "Priority" : 0 : "The priority value for this round (must be >= 0). Higher priority rounds will be picked first. If multiple rounds have the same priority value, a random selection will be used."
	
	cpr_cp_names(string) : "Control points in this round" :  : "Names of the control points included in this round (space delimited). Control points may belong to more than one control point round.  The names of the control points (and the rounds) should all be unique." 

	cpr_restrict_team_cap_win(choices) : "Restrict team from winning" : 0 : "Prevent this team from winning by capping all the points" =
	[
		0 : "Neither"
		1 : "Both"
		2 : "Red"
		3 : "Blue"
		4 : "Mercenary"
	]
	
	input RoundSpawn(void) : "Forces this entity to spawn. Fired automatically at the start of a round."
	
	output OnStart(void) : "Sent when this round is selected to be played."
	output OnEnd(void) : "Sent when this round is finished."
	output OnWonByTeam1(void) : "Sent when RED wins this round."
	output OnWonByTeam2(void) : "Sent when BLUE wins this round."
]


@PointClass base(BaseEntity, EnableDisable) iconsprite("editor-ficool2/team_round_timer") = team_round_timer :
	"Round Timer. Timer starts paused by default. The timer does not end the round on its own. You need a separate win condition such as the game_round_win entity."
[
	timer_length(integer) : "Timer length (in seconds)" : 600 : "Initial timer length."
	max_length(integer) : "Max timer length (in seconds)" : 0 : "Maximum timer length (0 = no max). This value is used to ensure the timer never goes above this value when SetTime and AddTime are used."
	
	start_paused(boolean) : "Start paused?" : 1 : "Should the timer start paused? (will need to send a Resume input to start the timer if this is set)."
	
	setup_length(integer) : "Setup timer length (in seconds)" : 0 : "Length of setup time before the round begins and the timer starts to countdown the normal time. (0 = no setup time)  Setup time is run at the beginning of every round before the normal time begins."
	
	reset_time(boolean) : "Reset time on round restart?" : 0 : "Reset the timer time after a round restart.  This is not the setup time, but the normal round time."
	
	auto_countdown(boolean) : "Use countdown sounds?" : 1 : "Let the timer automatically count down the end of a round."
	
	show_in_hud(boolean) : "Show timer in the HUD?" : 1 : "Note: You can only show one timer in the HUD at a time."
	
	show_time_remaining(choices) : "Count Direction" : 1 : "Use this to reverse the timer and have it count from 0 up to the timer length. Sounds and outputs still fire like normal. For example, on a count-up timer with a length of 90 seconds, when it reaches 60 the announcer will say '30 seconds remanining', however, the On30SecRemaining output will fire when the visual timer reaches 61." =
	[
		0 : "Up"
		1 : "Down"
	]
		
	input Pause(void) : "Pause the timer."
	input Resume(void) : "Resume the timer."
	input SetTime(integer) : "Set the timer to this value (in seconds)."
	input AddTime(integer) : "Add time to the timer (in seconds). Added time cannot excede the max timer length."
	input AddTeamTime(string) : "Input takes a string (space delimited) with the team number and the time to be added (in seconds) because of the team (2 for red, 3 for blue, and 0 for no team...but you could just use AddTime for that). Added time cannot excede the max timer length. Example: 2 600 (adds 10 minutes because of team red)" 
	input Restart(void) : "Restart the timer."
	input ShowInHUD(bool) : "Show this timer in the HUD (0 no, 1 yes)."
	input SetMaxTime(integer) : "Set the max timer length to this value (in seconds). The timer's time will never excede this value."
	input AutoCountdown(bool) : "Turn off/on the auto countdown feature (0 no, 1 yes)."
	input SetSetupTime(integer) : "Set the setup time length to this value (in seconds)."
	input RoundSpawn(void) : "Forces this entity to spawn. Fired automatically at the start of a round."
	
	output On5MinRemain(void) : "Sent when 5 minutes remain."
	output On4MinRemain(void) : "Sent when 4 minutes remain."
	output On3MinRemain(void) : "Sent when 3 minutes remain."
	output On2MinRemain(void) : "Sent when 2 minutes remain."
	output On1MinRemain(void) : "Sent when 1 minutes remain."
	output On30SecRemain(void) : "Sent when 30 seconds remain."
	output On10SecRemain(void) : "Sent when 10 seconds remain."
	output On5SecRemain(void) : "Sent when 5 seconds remain."
	output On4SecRemain(void) : "Sent when 4 seconds remain."
	output On3SecRemain(void) : "Sent when 3 seconds remain."
	output On2SecRemain(void) : "Sent when 2 seconds remain."
	output On1SecRemain(void) : "Sent when 1 second remains."
	
	output OnRoundStart(void) : "Sent when the round starts."
	output OnFinished(void) : "Sent when the timer is finished."
	
	output OnSetupStart(void) : "Sent when the setup time begins."
	output OnSetupFinished(void) : "Sent when the setup time is finished."
]

@PointClass base(BaseEntity, TeamNum, EnableDisable) iconsprite("editor-ficool2/team_train_watcher") = team_train_watcher :
	"Entity that tracks the train progress through train escort maps. Adding this entity to a map makes Team Fortress 2 classify the map as a train escort (Payload) map."
[
	train(target_destination) : "Train to watch."
	train_can_recede(choices) : "Allow the train to recede?" : 1 =
	[
		0 : "No"
		1 : "Yes"
	]
	
	train_recede_time(integer) : "Train recede time (in seconds)" : 0 : "Length of time before the train begins to recede. 0 = use TF2 default setting of 30 seconds."
	
	handle_train_movement(choices) : "Handle Train Movement?" : 0 : "If Yes, the watcher will handle three-speed forward movement, receding, and roll forward/back zones. Slow areas (such as for uphill) will need to be done manually by sending the watcher a SetSpeedForwardModifier input." =
	[
		0 : "No"
		1 : "Yes"
	]
	speed_forward_modifier(float) : "Default Speed Modifier" : 1 : "0 to 1 scaling of the train's max speed. Can be adjusted with the SetSpeedForwardModifier input. Only functions with Handle Train Movement enabled."
	env_spark_name(target_destination) : "Associated env_spark" : : "Name of the env_spark to turn on when the cart is receding. Only functions with Handle Train Movement enabled."

	start_node(target_destination) : "Node that the path starts at."
	goal_node(target_destination) : "Node that the path ends at."
	
	linked_pathtrack_1(target_destination) : "Linked PathTrack 1"
	linked_cp_1(target_destination) : "Linked CP 1"
	
	linked_pathtrack_2(target_destination) : "Linked PathTrack 2"
	linked_cp_2(target_destination) : "Linked CP 2"
	
	linked_pathtrack_3(target_destination) : "Linked PathTrack 3"
	linked_cp_3(target_destination) : "Linked CP 3"
		
	linked_pathtrack_4(target_destination) : "Linked PathTrack 4"
	linked_cp_4(target_destination) : "Linked CP 4"
		
	linked_pathtrack_5(target_destination) : "Linked PathTrack 5"
	linked_cp_5(target_destination) : "Linked CP 5"
		
	linked_pathtrack_6(target_destination) : "Linked PathTrack 6"
	linked_cp_6(target_destination) : "Linked CP 6"
		
	linked_pathtrack_7(target_destination) : "Linked PathTrack 7"
	linked_cp_7(target_destination) : "Linked CP 7"
		
	linked_pathtrack_8(target_destination) : "Linked PathTrack 8"
	linked_cp_8(target_destination) : "Linked CP 8"
		
	hud_min_speed_level_1(float) : "Min Speed for Speed Level 1" : 1
	hud_min_speed_level_2(float) : "Min Speed for Speed Level 2" : 60
	hud_min_speed_level_3(float) : "Min Speed for Speed Level 3" : 80
	
	input SetNumTrainCappers(integer) : "Set Number of players capping the train."
	input SetSpeedForwardModifier(float)
	input SetTrainRecedeTime(integer) : "Set the number of seconds before the train starts to recede."
	input SetTrainCanRecede(bool) : "Determines whether or not the train can recede."
	input SetTrainRecedeTimeAndUpdate(integer) : "Set the number of seconds before the train starts to recede and update the current recede time."
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
	
	output OnTrainStartRecede(void) : "Sent when the train should start receding."
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/test_effect") = test_effect : 
	"Creates rays inside a small sphere shape for 5 seconds. Requires an 'Use' input. Repeatable."
[
]

@PointClass base(BaseEntityPoint) iconsprite("editor-ficool2/test_traceline") = test_traceline : 
	"An entity used for debugging tracelines. Fires a white line upwards, which rotates 90 degrees down gradually, stops, and then rotates 90 degrees up gradually and so on. Creates a tiny green box at its origin, which becomes red if the entity is unable to fire the trace its line."
[
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/tf_gamerules") = tf_gamerules : 
    "Proxy entity for Team Fortress 2 game rules."
[	
	UsesHL2Hull(boolean) : "HL2 Player Hulls?" : 0 : "Change whether to use Half Life 2 hulls for players (allows fitting into smaller spaces)"
	Force3DSkybox(boolean) : "Force 3D Skybox?" : 0 : "Force 3D Skybox to always be on, even if disabled by client."
	UsesMoney(boolean) : "Uses Money?" : 0 : "Whether or not to display currency on your HUD."
	
	input SetRedTeamRespawnWaveTime(float) : "Set the RED team's respawn wave time."
	input SetBlueTeamRespawnWaveTime(float) : "Set the BLU team's respawn wave time."
	input SetMercenaryTeamRespawnWaveTime(float) : "Set the Mercenary team's respawn wave time."
	input AddRedTeamRespawnWaveTime(float) : "Add to the RED team's respawn wave time."
	input AddBlueTeamRespawnWaveTime(float) : "Add to the BLU team's respawn wave time."
	input AddMercenaryTeamRespawnWaveTime(float) : "Add to the Mercenary team's respawn wave time."
	input SetRedTeamGoalString(string) : "Set the RED team's goal string to show in the hud."
	input SetBlueTeamGoalString(string) : "Set the BLU team's goal string to show in the hud."
	input SetMercenaryTeamGoalString(string) : "Set the Mercenary team's goal string to show in the hud."
	input SetRedTeamRole(integer) : "Set RED team role, 0=none, 1=defenders, 2=attackers."
	input SetBlueTeamRole(integer) : "Set BLU team role, 0=none, 1=defenders, 2=attackers."
	input SetMercenaryTeamRole(integer) : "Set Mercenary team role, 0=none, 1=defenders, 2=attackers."
	input SetStalemateOnTimelimit(bool) : "Determines whether mp_timelimit can end the match in the middle of a round."
	input SetRedKothClockActive(void) : "Set the RED team clock active for KOTH maps."
	input SetBlueKothClockActive(void) : "Set the BLU team clock active for KOTH maps."
	input PlayVORed(string) : "Play the given sound entry via the VO channel." 
	input PlayVOBlue(string) : "Play the given sound entry via the VO channel."
	input PlayVOMercenary(string) : "Play the given sound entry via the VO channel."	
	input PlayVO(string) : "Play the given sound entry via the VO channel."
	
	output IsCTF(void) : "Fired if the gamemode is detected to be Capture the Flag."
	output IsCP(void) : "Fired if the gamemode is detected to be Control Point."
	output IsDM(void) : "Fired if the gamemode is detected to be Deathmatch."
	output IsTeamplay(void) : "Fired if the gamemode is detected to be Team Deathmatch."
	output IsGunGame(void) : "Fired if the gamemode is detected to be Gun Game."
]

@PointClass base(Model, BaseAnimating) studioprop() = tf_generic_bomb :
    "An explosive hazard. Identical to tf_pumpkin_bomb, but more customizable."
[
	damage(float) : "Explosion Damage" : 50 : "Amount of damage to do when exploding."
	radius(float) : "Explosion Radius" : 100 : "Explosion radius."
	health(integer) : "Health" : 1 : "Health of the bomb."
	explode_particle(string) : "Explosion Particle" :  : "Name of the particle effect to play when exploding."
	sound(sound) : "Explosion Sound" :  : "Name of the sound effect to play when exploding."
	friendlyfire(choices) : "Friendly Fire" : 0 : "Set the friendly fire mode." =
	[
		0 : "Damage attacker and enemies"
		1 : "Damage everyone"
	]

	input Detonate(void) : "Force detonation."

	output OnDetonate(void) : "Fired when this bomb detonates."
]

@PointClass base(BaseEntity, EnableDisable) iconsprite("editor-ficool2/tf_glow") = tf_glow
[
	target(target_destination) : "Target" : : "Target to glow. Only one can be assigned, and it cannot be changed even with AddOutput."
	GlowColor(color255) : "Glow Color" : "255 0 0 255" : "Glow color, with alpha. Format: <R> <G> <B> <A> 0-255"
	Mode(choices) : "Visibility Mode" : 0 : "When the glow should be visible" =
	[
		0 : "Always"
		1 : "Only when model is occluded"
		2 : "Only when model is visible"
	]
	
	input SetGlowColor(color255) : "Set the glow color, with alpha. Format: <R> <G> <B> <A> 0-255"
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/tf_logic_arena") = tf_logic_arena :
    "Enables arena mode."
[
	CapEnableDelay(integer) : "Control Point Enable Time" : 60 : "Time (in seconds) before the control point unlocks."
	
	output OnArenaRoundStart(void) : "Sent when round begins."
	output OnCapEnabled(void) : "Sent when control point unlocks."
]

@PointClass base(BaseEntity) iconsprite("editor-ficool2/tf_logic_koth")  = tf_logic_koth :
    "King of the Hill Entity. This is used to detect a KOTH map."
[	
	timer_length(integer) : "Timer length (in seconds)" : 180 : "Initial timer length for each team."
	unlock_point(integer) : "Unlock Point (in seconds)" : 30 : "Time to wait before unlocking the point in CP KOTH maps."

	input SetRedTimer(integer)	:	"Set the time remaining for the RED timer."
	input SetBlueTimer(integer)	:	"Set the time remaining for the BLUE timer."
	input AddRedTimer(integer)	:	"Add time to the RED timer."
	input AddBlueTimer(integer)	:	"Add time to the BLUE timer."
	input RoundSpawn(void) : "Forces this entity to spawn. Fired automatically at the start of a round."
	input RoundActivate(void) : "Forces this entity to activate. Fired automatically at the start of a round."
]

@PointClass base(BaseEntityPoint) studioprop("models/editor-ficool2/cone_helper_gray.mdl") = tf_point_weapon_mimic :
    "An entity that shoots like player weapons."
[
	WeaponType(choices) : "Weapon Type" : 0 : "Which projectiles to fire." =
	[
		0 : "Rockets"
		1 : "Grenades"
		2 : "Arrows (NOT SUPPORTED)"
		3 : "Stickies"
	]

	FireSound(sound)		: "Fire Sound"		: 	: "The sound to be played when we fired."
	ParticleEffect(string)	: "Particle Effect"	: 	: "The particle effect to be played when we fired."
	ModelOverride(studio)	: "Model Override"	: 	: "The model to apply onto projectiles we fire."
	ModelScale(float)		: "Model Scale"		: "1"	: "Scale for the projectile model."
	SpeedMin(float)			: "Minimum Speed"	: "1000": "Minimum speed for each projectile."
	SpeedMax(float)			: "Maximum Speed"	: "1000": "Maximum speed for each projectile."
	Damage(float)			: "Damage"			: "75"	: "Damage for the projectile."
	SplashRadius(float)		: "Splash Radius"	: "50"	: "Splash radius for the projectile."
	SpreadAngle(float)		: "Spread Angle"	: "0"	: "Random spread for each projectile fired."
	Crits(boolean) : "Always Crits?" : 0 : "All shots are crits."

	input FireOnce(void)			: "Fire once."
	input FireMultiple(integer)		: "Fire multiple projectiles at once."
	input DetonateStickies(void)	: "Detonate stickies, if used."
]

@PointClass base(BaseAnimating) studioprop("models/props_halloween/pumpkin_explode.mdl") = tf_pumpkin_bomb :
    "tf_pumpkin_bomb is a explosive hazard generally used in the official Team Fortress 2 Halloween maps. In the official maps, they are spawned by a entity_spawn_manager."
[
]

@SolidClass base(Trigger, Condition) = trigger_add_tf_player_condition :
	"A trigger that will add a condition to players."
[
	duration(float)			: "Duration"		:  0	: "The duration of the condition. NOTE: -1 duration means last until the player exits the trigger."
]

@SolidClass base(Trigger) = trigger_apply_impulse : 
    "A trigger that adds impulse to touching entities. It will only apply the impulse upon receiving an ApplyImpulse input."
[
    impulse_dir(angle) : "Impulse Direction (Pitch Yaw Roll)" : "0 0 0" : "Angles indicating the direction to push touching entities. Does not orient relative to parent angles."
    force(float) : "Impulse Force" : "300" : "The amount of force to apply to the touching entities."
 
    input ApplyImpulse(void)  : "Apply impulse to touching entities"
]

@SolidClass base(BaseAnimatingBrush) = trigger_brush :
	"Obsolete from Half Life 2 beta. A generic, solid brush which has unique coding for the Use function compared to other brush entities."+
	"NOTE: The player events (such as game_playerdie) are useable by all entities and not just by this entity, despite common misconception. See developer.valvesoftware.com/wiki/Targetname#Player_Events"
[
    DontMessageParent(boolean) : "Don't Message Parent?" : 0 : "Makes the trigger_brush intercept the StartTouch/EndTouch/Use events, only sending its own output without passing the event on to its BaseClass."
	
	InputFilter(choices) : "Input Filter" : 0 : "Used to specify which inputs this entity will accept." =
	[
		0 : "Allow all inputs"
		8 : "Ignore Touch/Untouch"
		16 : "Ignore Use"
		32 : "Ignore All"
	]

	spawnflags(flags) =
	[
		2: "Ignore Player +Use" : 1
	]
	
	input Enable(void) : "Enables the brush."
	input Disable(void) : "Disables the brush."
	
	output OnUse(void) : "Fired when the entity is used, either via a special function or by a player (if the Ignore Player +Use spawnflag is unticked). The !activator is the person who triggered this entity."
	output OnStartTouch(void) :	"Fired when an entity starts touching this trigger. " +
					"The touching entity must pass this trigger's filters " +
					"to cause this output to fire."
	output OnEndTouch(void) :	"Fired when an entity stops touching this trigger. " +
					"The touching entity must pass this trigger's filters " +
					"to cause this output to fire."
]

@SolidClass base(Trigger, TeamNum ) = trigger_capture_area : 
    "Capture area for a team_control_point to make a capture point. Also used to define the push/block zone around a Payload cart when a func_tracktrain is defined as its parent."
[
	area_cap_point(target_source) : "Control point" :  : "Name of the control point this area is linked to."

	team_cancap_2(choices) : "Can RED Cap?" : 1 = 
	[
		1 : "Yes"
		0 : "No"
	]
	team_cancap_3(choices) : "Can BLUE Cap?" : 1 = 
	[
		1 : "Yes"
		0 : "No"
	]
	
	team_cancap_4(choices) : "Can Mercenary Cap?" : 1 = 
	[
		1 : "Yes"
		0 : "No"
	]
	
	team_startcap_2(integer) : "Number of RED players to start capping" : 1 
	team_startcap_3(integer) : "Number of BLUE players to start capping" : 1 
	team_startcap_4(integer) : "Number of Mercenary players to start capping" : 1 
	
	team_numcap_2(integer) : "Number of RED players to cap" : 1 
	team_numcap_3(integer) : "Number of BLUE players to cap" : 1 
	team_numcap_4(integer) : "Number of Mercenary players to cap" : 1 
	
	team_spawn_2(integer) : "Red Spawn Adjust" : 0 : "Adjust the minimum respawn time for the red team by this amount (in seconds) when red captures this point. If the red team owns this point when blue captures it, this adjustment is reversed."
	team_spawn_3(integer) : "Blue Spawn Adjust" : 0 : "Adjust the minimum respawn time for the blue team by this amount (in seconds) when blue captures this point. If the blue team owns this point when red captures it, this adjustment is reversed."
	team_spawn_4(integer) : "Mercenary Spawn Adjust" : 0 : "Adjust the minimum respawn time for the Mercenary team by this amount (in seconds) when Mercenary captures this point. If the Mercenary team owns this point when red/blue captures it, this adjustment is reversed."
	
	
	area_time_to_cap(integer) : "Time to cap (sec)" : 5 

	input SetTeamCanCap(string) : "Set whether a specific team is allowed to capture this point. Format is: <team number> <(0/1)>. i.e. '2 0' would prevent RED from capturing this point, whereas '3 1' would allow BLUE to cap it."
	input SetControlPoint(string) : "Assign area capture to the passed control point."
	input CaptureCurrentCP(string) : "If we're being capped, forces the current point to capture."
	
	output OnStartTeam1(void) : "Sent when RED start capture."
	output OnBreakTeam1(void) : "Sent when a RED capture is broken."
	output OnCapTeam1(void)   : "Sent when RED end capture."

	output OnStartTeam2(void) : "Sent when BLU start capture."
	output OnBreakTeam2(void) : "Sent when a BLU capture is broken."
	output OnCapTeam2(void)   : "Sent when BLU end capture."

	output OnStartCap(void) : "Sent when either team starts capture."
	output OnBreakCap(void) : "Sent when either team break capture."
	output OnEndCap(void)   : "Sent when either team end capture."
	
	output OnNumCappersChanged(integer) : "Sent when the number of cappers changes, passes the value in int."
	output OnNumCappersChanged2(integer) : "Sent when the number of cappers changes, passes the value in int (-1 for capture blocked)."
]

@SolidClass base(Trigger) = trigger_gravity : 
	"A trigger volume that changes the gravity keyvalue on any entity that touches it. Only players can have their gravity changed."
[
	gravity(integer) : "Gravity" : 1 : "Gravity multiplier. 1 is normal gravity, 0.001 is none. A value of 0 cannot be used! Accepts negative values and decimals."
]

@SolidClass base(Trigger, DamageType) = trigger_hurt :
	"A trigger volume that damages entities that touch it."
[
	master(string) : "Master (Obsolete)" : : "Legacy support: The name of a master entity. If the master hasn't been activated, this entity will not activate."
	damage(integer) : "Damage" : 10 : "The amount of damage done to entities that touch this trigger. The specified damage will be halved, for technical reasons. The damage is done every half-second. Negative values will heal."
	damagecap(integer) : "Damage Cap" : 20 : "Maximum damage dealt per second. This field is only used if you select the Doubling w/Forgiveness damage model, via the spawnflag."

	damagemodel(choices) : "Damage Model" : 0 : "How damage is dealt. Normal always does the specified amount of damage each half second. Doubling starts with the specified amount and doubles it each time it hurts the toucher. Forgiveness means that if the toucher gets out of the trigger the damage will reset to the specified value. Good for making triggers that are deadly over time without having to cause massive damage on each touch." =
	[
		0 : "Normal"
		1 : "Doubling w/forgiveness"
	]
	
	nodmgforce(boolean) : "Zero Damage Force?" : 0 : "Should the damaged entity receive no physics force from this trigger."
	
	input SetDamage(float) : "Set a new amount of damage for this trigger."
	
	output OnHurt(void) : "Fired whenever this trigger hurts something other than a player."
	output OnHurtPlayer(void) : "Fired whenever this trigger hurts a player."
]

@SolidClass base(Trigger) = trigger_impact : 
	"A trigger volume that can be told to push all physics objects that are inside of it in the direction specified by this trigger's angles.\n"+
	"Also outputs the force at the time of impact for anyone else that wants to use it."
[
	Magnitude(float) : "Magnitude" : 200    : "The strength of the impact. Negative values reverse the direction."
	noise(float) : "Noise" : "0.1" : "The amount of directional noise (0-1). 0 = no noise, 1 = random direction."
	viewkick(float) : "Viewkick" : "0.05" : "The amount to kick player's view if the player is in the trigger.  Proportional to magnitude (0-1)."

	input Impact(float) : "Fire the impact, pushing all entities within the volume."
	input SetMagnitude(float) : "Set the magnitude of the impact."

	output ImpactForce(string) : "Fired after an impact. The parameter passed along is the force of the impact that was generated."
]

@SolidClass base(Trigger) = trigger_look :
	"An entity used to trigger something when the player looks at something. It fires 'OnTrigger' when the player "+
	"looks at a target entity for the given amount of time, while within the trigger volume. If the player leaves "+
	"the trigger or looks away from the target entity the clock resets. If the 'Use Velocity instead of facing' spawnflag " +
	"is checked, the trigger uses the player's velocity instead of the player's view, so it determines whenever the player "+
	"is moving toward the target entity. Useful for triggering when players are driving a vehicle at something. "+
	"Does not function in multiplayer."
[
	target(target_destination) : "Look Target" : : "The name of the entity to be looked at."
	LookTime(string) : "LookTime" : "0.5" : "The time, in seconds, that the player must look the target before firing the output. Resets if player leaves trigger, or looks outside the Field of View threshold."
	FieldOfView(string) : "FieldOfView" : "0.9" : "How close the player has to be looking at the target. 1.0 = straight ahead\n 0.0 = +/- 90 degrees\n -1.0 = all directions)."
	Timeout(float) : "Timeout" : "0" : "The time, in seconds, to wait after player enters the trigger before firing the OnTimeout output, 0 = never."

	spawnflags(flags) = 
	[ 
		128: "Fire Once" : 1 
		256: "Use Velocity instead of facing" : 0
	]
	
	output OnTrigger(void) : "Fired when the trigger is activated."
	output OnTimeout(void) : "Fired after the timeout interval expires if the player never looked at the target."
]

@SolidClass base(Trigger) = trigger_multiple :
	"A trigger volume that can be triggered multiple times."
[
	wait(integer) : "Delay Before Reset" : 1 : "Amount of time, in seconds, after the trigger_multiple has triggered before it can be triggered again. If set to -1, it will never trigger again (in which case you should just use a trigger_once)."
]

@SolidClass base(Trigger) = trigger_once :
	"A trigger volume that removes itself after it is triggered once."
[
]

@SolidClass base(Trigger) = 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_playermovement : 
	"An entity that Can be used to control player's movement options, for instance by automatically ducking or forcing walking speed."
[
	spawnflags(flags) = 
	[
		128: "Disable auto player movement" : 1
		2048: "Auto-duck while in trigger" : 0
		4096: "Auto-walk while in trigger" : 0
	]
]

@SolidClass base(Trigger) sphere(radius) = trigger_proximity :
	"Measures the distance of the player within the trigger volume from a given point (and within " +
	"a given radius). The NearestPlayerDistance output will be 0 when the player is at the center point, " +
	"and 1 when the player is at the radius."
[
	measuretarget(target_destination) : "Point to Measure From" : : "The name of a target entity who's origin is the point to measure the player's distance from."
	radius(string) : "Radius to measure within" : 256 : "The radius to which the distance should be mapped. If the player is outside the radius he will be ignored."
	
	output NearestEntityDistance(integer) : "Fired continuously when entities are touching the trigger volume. The output parameter is the distance from the "+
						"Point to Measure From to the nearest entity that passed the trigger filters. The distance is mapped to the radius distance, "+
						"so it will be 0 when the entity is on the point, and 1 when the entity is at the edge of the radius."
]

@SolidClass base(Trigger) = trigger_push : 
	"A trigger volume that pushes entities that touch it, except those with a parent."
[
	pushdir(angle) : "Push Direction (Pitch Yaw Roll)" : "0 0 0" : "Angles indicating the direction to push touched entities."
	speed(integer) : "Speed of Push" : 40 : "The speed at which to push entities away, in units / second."
	alternateticksfix(float) : "Scale force for alternate ticks" : "0" : "If nonzero, scale the force by this amount when running with alternate ticks. This fixes problems with an overly large force due to the longer frametime on when running with sv_alternateticks 1."

    // need to include spawnflags here again because of a Hammer bug
	spawnflags(flags) = 
	[ 
		128: "Once Only (possibly means set velocity rather than apply acceleration)" : 0
		256: "Affects Ladders" : 0 
		1: "Clients/Players/Bots" : 1
		2: "NPCs" : 0
		4: "Pushables": 0
		8: "Physics Objects" : 0
		16: "Only player ally NPCs" : 0
		32: "Only clients in vehicles" : 0
		64: "Everything (not including physics debris)" : 0
		512: "Only clients *not* in vehicles" : 0
		1024: "Physics debris" : 0
		2048: "Only NPCs in vehicles (respects player ally flag)" : 0
		4096: "Disallow Bots" : 0				   
	]
]

@SolidClass base(Trigger) = trigger_remove : 
	"A trigger volume that removes any entities that touch it completely from the game. Be careful, removing some entities can cause instability or crashing, especially with a player."
[
	output OnRemove(void) : "Fired whenever an entity is removed."
]

@SolidClass base(Trigger, Condition) = trigger_remove_tf_player_condition :
	"A trigger that will remove a condition (or all if set to INVALID) from a player."
[
]

@SolidClass base(Trigger) = trigger_soundscape : 
	"Automatically triggers an env_soundscape_triggerable whenever a player is inside its volume and not triggering any other soundscape entities."
[
	soundscape(target_source) : "Soundscape" : : "The env_soundscape_triggerable that this brush triggers. (Not to be confused with the actual soundscape that the env_soundscape_triggerable then calls.)"
]

@SolidClass base(Trigger) = trigger_teleport : 
	"A trigger volume that teleports entities that touch it. Entities are teleported to the Remote Destination, and have their angles "+
	"set to that of the Remote Destination's. If a Local Destination Landmark is specified, teleported entities are offset from the target "+
	"by their initial offset from the landmark, and their angles are left alone."
[
	target(target_destination) : "Remote Destination" : : "The entity specifying the point to which entities should be teleported."
	landmark(target_destination) : "Local Destination Landmark" : : "If specified, then teleported entities are offset from the target by their initial offset from the landmark."

	// have to re-define all flags due to a Hammer bug
	spawnflags(flags) = 
	[
		1: "Clients/Players/Bots" : 1
		2: "NPCs" : 0
		4: "Pushables": 0
		8: "Physics Objects" : 0
		16: "Only player ally NPCs" : 0
		32: "Preserve angles even when a local landmark is not specified" : 0
		64: "Everything (not including physics debris)" : 0
		512: "Only clients *not* in vehicles" : 0
		1024: "Physics debris" : 0
		2048: "Only NPCs in vehicles (respects player ally flag)" : 0
		4096: "Disallow Bots" : 0
		8192: "Adjust Angles (Requires landmark!)" : 0
	]
]

@SolidClass base(BaseEntityBrush, EnableDisable) = trigger_vphysics_motion :
	"A volumetric trigger that affects the motion of physical objects that touch it. Optionally, it can also create a particle trail. A particle trail, when parented, takes the shape of a model or brush. Players cannot jump when in contact with this brush."
[
	filtername(filterclass) : "Filter Name" : : "Filter to use to see if activator triggers me."
	
	SetGravityScale(float) : "Scale gravity of objects in the field." : "1.0"
	SetAdditionalAirDensity(float) : "Additional air density for drag" : "0"
	
	SetVelocityLimit(float) : "Max velocity in field (0 disables)" : "0.0"
	SetVelocityLimitDelta(float) : "Max amount to reduce velocity per second when it exceeds the velocity limit (0 disables)" : "0.0"
	SetVelocityScale(float) : "Velocity scale/drag" : "1.0"

	SetAngVelocityLimit(float) : "Maximum angular velocity in field (degrees/s, 0 disables)" : "0.0"
	SetAngVelocityScale(float) : "Angular Velocity scale/drag" : "1.0"

	SetLinearForce(float) : "Linear force (0 disables)" : "0.0"
	SetLinearForceAngles(angle) : "Direction of linear force (Pitch Yaw Roll (Y Z X))" : "0 0 0"

	ParticleTrailMaterial(material) : "Particle Trail Material (Optional)" : : "Name of a material to use for the particle trail, optionally."
	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."

	spawnflags(Flags) =
	[
		4096 : "Can move (through hierarchical attachment)" : 0
	]
	
	input SetGravityScale(float) : "Set the scale gravity of objects in the field."	
	input SetAdditionalAirDensity(float) : "Set the additional air density for drag."
	input SetVelocityLimit(float) : "Set the maximum velocity in field."
	input SetVelocityLimitDelta(float) : "Set the maximum amount to reduce velocity per second."
	input SetVelocityLimitTime(vector) : "Accepts two arguments: the first is the new velocity limit, the second is the time it takes to ramp to that value."
	input SetVelocityScale(float) : "Set the Velocity scale/drag,"
	input SetAngVelocityLimit(float) : "Set the Maximum Angular Velocity in field."
	input SetAngVelocityScale(float) : "Set the Angular Velocity scale/drag."
	input SetLinearForce(float) : "Set the Linear force (0 disables)."
	input SetLinearForceAngles(vector) : "Direction of linear force, in X Y Z."
	
	input Toggle(void) : "Toggle enable/disable."
]

@SolidClass base(Trigger) = trigger_wind : 
	"A trigger volume that pushes physics objects that touch it."
[
	Speed(integer) : "Speed" : 200   : "The baseline for how hard the wind blows."
	SpeedNoise(integer) : "Speed Noise" : 0 : "Noise added to wind speed +/-"
	DirectionNoise(integer) : "Direction Noise" : 10 : "Noise added to wind direction."
	HoldTime(integer) : "Hold Time"	: 0 : "Baseline for how long to wait before changing wind."
	HoldNoise(integer) : "Hold Noise" : 0 : "Noise added to how long to wait before changing wind."
	
	spawnflags(flags) = 
	[ 
		4096: "Motion Moveable - Warning: Using this with any other flags checked will cause immediate map load crashes!" : 0 
	]

	input SetSpeed(integer) : "Set the baseline for how hard the wind blows."
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/axis_helper_thick.mdl") = vgui_screen : 
	"A VGUI screen. Useful for in-world monitors. This is used by the Engineer's Dispenser for the metal counter." 
[
	panelname(string) : "Panel Name" : : "Name of the panel to use. This is not a filename."
	overlaymaterial(string) : "Overlay Material" :  : "Name of a material to overlay over the top of the VGUI screen. This material must write Z for the VGUI screen to work."
	width(integer) : "Panel Width" : 32 : "Width of the panel in units."
	height(integer) : "Panel Height" : 32 : "Height of the panel in units."

	input SetActive(void) : "Make the screen visible."
	input SetInactive(void) : "Make the screen invisible."
]

@PointClass base(vgui_screen, TeamNum) studioprop("models/editor/axis_helper_thick.mdl") = vgui_screen_team : 
	"Identical to vgui_screen, but supports teams. Regardless, this entity appears to be unused." 
[
]

@PointClass base(BaseEntityPoint) studioprop("models/editor/axis_helper_thick.mdl") = vgui_slideshow_display : 
    "A VGUI screen the displays images in a slideshow. See https://developer.valvesoftware.com/wiki/Vgui_slideshow_display for a full explanation on the usage of this."
[
	displaytext(string) : "Display Text" : : "Text to display on top of the image."

	directory(string) : "Image Directory (materials/vgui/...)" : "slideshow" : "Directory where images are located (materials/vgui/[directory])."

	minslidetime(float) : "Min Slide Time" : "0.5" : "Minimum amount of random time that a slide is displayed."
	maxslidetime(float) : "Max Slide Time" : "0.5" : "Maximum amount of random time that a slide is displayed."

	cycletype(choices) : "Cycle Type" : 0 : "Order that images are displayed." = 
	[
		0 : "Random"
		1 : "Forward"
		2 : "Backward"
	]

	nolistrepeat(choices) : "List Repeats?" : 0 = 
	[
		0 : "Allow List Repeats"
		1 : "No List Repeats"
	]

	width(integer) : "Panel width" : 256 : "Width of the panel in units."
	height(integer) : "Panel height" : 128 : "Height of the panel in units."

	input Enable(void) : "Make slideshow visible."
	input Disable(void) : "Make slideshow invisible."

	input SetDisplayText(string) : "Sets the display text."

	input RemoveAllSlides(void) : "Removes all slides from slideshow."
	input AddSlides(string) : "Adds slides by keyword."

	input SetMinSlideTime(float) : "Sets min random time between slides."
	input SetMaxSlideTime(float) : "Sets max random time between slides."

	input SetCycleType(integer) : "0 - random, 1 - forward, 2 - backward"
	input SetNoListRepeat(bool) : "Sets if lists can be randomly picked twice in a row."
]

@PointClass base(BaseEntity) iconsprite("editor/waterlodcontrol") = water_lod_control : 
	"An entity used to control the LOD behavior of any water in the map. If your map has water, this entity is required. Otherwise, it is automatically created."
[
	cheapwaterstartdistance(float) : "Start Transition to Cheap Water" : 1000 : "This is the distance from the camera that water will start transitioning to cheap water, in units."
	cheapwaterenddistance(float) : "End Transition to Cheap Water" : 2000 : "This is the distance from the camera that water will finish transitioning to cheap water, in units."

	input SetCheapWaterStartDistance(float) : "Set the distance that water starts transitioning to cheap water."
	input SetCheapWaterEndDistance(float) : "Set the distance that water finishes transitioning to cheap water."
]

@SolidClass base(BaseEntity) = worldspawn : 
	"This is the world entity. Each map can only contain one, and it's automatically created for you."
[
	skyname(string) : "Skybox Texture Name" : "sky_tf2_04" : "Skybox material. See https://developer.valvesoftware.com/wiki/Team_Fortress_2_Sky_List for a default list. This can be changed at runtime with AddOutput, although the player must re-connect to see the change."
	maxoccludeearea(float) : "Max occludee area" : "0" : "Prevents occlusion testing for entities that take up more than X% of the screen." 
	minoccluderarea(float) : "Min occluder area" : "0" : "Prevents occluders from being used if they take up less than X% of the screen." 
	maxpropscreenwidth(float) : "Start Fade Pixels" : -1 : "Number of pixels wide at which all props in the level start to fade (<0 = use fademaxdist). This number is ignored if the prop has a specific fade distance specified."
	minpropscreenwidth(float) : "End Fade Pixels" : 0 : "Minimum number of pixels wide at which the prop is visible (0 = don't fade out). This number is ignored if the prop has a specific fade distance specified."
	detailvbsp(string) : "Detail.vbsp file" : "detail.vbsp" : "Detail.vbsp file to use for emitting detail props (found in directory <root>/modname)."
	detailmaterial(string) : "Detail material file" : "detail/detailsprites" : "Material for detail sprites to use for drawing detail props."
	no_decomp(boolean) : "Disallow Decompiling?" : 0 : "If Yes, then VMEX will refuse to decompile the map. Newer third-party decompilers and tools bypass this, so this is effectively obsolete."
	_minlight(float) : "Map Geometry Minimum Light Level" : 0 : "Forces the minimum intensity of light part of the map geometry to be at least this. Expressed as a float from 0.0 to 2.0, with 0.0 being pitch black (default) and 2.0 being fullbright. Does not affect props."
]

// valve... valve!!!!!!!!!

@PointClass size( -8 -8 -8, 8 8 8 ) instance() = func_instance : 
	"An entity for placing an instance of a map file.  You may translate and rotate this entity. " +
	"You can use the replace keys to do parameter changes on the instance contents.  In a $ at the " +
	"beginning of a variable name.  Then just use the $variable name inside of the instance contents on any "+
	"value portion of a key/value pair."
[
	angles(angle) : "Pitch Yaw Roll (Y Z X)" : "0 0 0" : "This entity's orientation in the world. Pitch is rotation around the Y axis, yaw is the rotation around the Z axis, roll is the rotation around the X axis."
	targetname(target_source) : "Fix Up Name" : : "The name that all entities will be fixed up with based upon the fix up style."
	file(instance_file) : "VMF Filename" : : "This indicates a map file relative to the map's file name"
	fixup_style(Choices) : "Entity Name Fix Up" : 0 : "Fixup style for instanced entity names.  Uses the 'Fix Up Name' field." =
	[
		0 : "Prefix"
		1 : "Postfix"
		2 : "None"
	]

	replace01(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace02(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace03(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace04(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace05(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace06(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace07(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace08(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace09(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
	replace10(instance_variable) : "Replace" : : "This is a replacement parameter.  It goes in the form of $variable value.  All entities inside of that instance that have $variable somewhere will be replaced with the value contents.  Example: $color 255 0 0"
]

@PointClass iconsprite("editor-ficool2/func_instance_parms") = func_instance_parms : 
	"Place one copy of this entity inside of an instance.  Whenever you add a $parameter for the instance, get the properties " +
	"of this entity.  It will auto-populate it with the variables and allow you to indicate the variable type."
[
	parm1(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm2(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm3(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm4(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm5(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm6(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm7(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm8(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm9(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
	parm10(instance_parm) : "Parm" : : "This is a parameter.  It goes in the form of $variable type."
]

@PointClass = func_instance_origin : 
	"This is the center of the instance for rotation."
[
]

// hardcoded mess again

// Purpose: Easy entity definitions for Propper. v0.3
// Fixed for compatibility with ficool2's fgd
// See http://developer.valvesoftware.com/wiki/Propper

@BaseClass = Angles2
[ 
	angles(angle) : "Pitch Yaw Roll (Y Z X)" : "0 0 0" : "This entity's orientation in the world. Pitch is rotation around the Y axis, " +
		"yaw is the rotation around the Z axis, roll is the rotation around the X axis."
]

@BaseClass = Origin2
[ 
	origin(origin) : "Origin (X Y Z)" : : "The position of this entity's center in the world. Rotating entities typically rotate around their origin."
]

@BaseClass = Targetname2
[ 
	targetname(target_source) : "Name" : : "The name that other entities refer to this entity by."

]

@BaseClass = Propper
[ 
	my_model(target_destination) : "Model to apply to" : "" : "Pick a propper_model entity for this property to apply to."
]

@PointClass base(Targetname2, Origin2, Angles2, Propper) studio("models/editor/axis_helper.mdl") = propper_attachment :
    "An attachment is an arbitrary point you can define in a model. They have several uses."
[
]

@SolidClass base(Propper, Origin2) = propper_lod :  
    "A low-res version of the model to show at long distance."
[
	weldvertices(float) : "Welding threshold" : ".01" : "Vertices will be snapped together if within this tolerance. Larger numbers will merge vertices together, and may be useful for optimizing your model."
	distance(integer) : "LOD switch distance" : 0 : "The distance for the LOD to appear. This is actually a combination of how far the player is from the model and their screen resolution (100*units/pixel). Bigger numbers are farther away." 
]
@PointClass base(Propper) iconsprite("editor/logic_case.vmt") = propper_bodygroup : 
    "Bodygroups allow you to swap between parts of a mesh. For example, you could have a door with several different knobs and allow the mapper to pick one."
[
	groupname(string) : "Bodygroup name" : "" : "A name for the bodygroup. This is required."
	body01(target_destination) : "Body Part 01" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body02(target_destination) : "Body Part 02" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body03(target_destination) : "Body Part 03" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body04(target_destination) : "Body Part 04" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body05(target_destination) : "Body Part 05" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body06(target_destination) : "Body Part 06" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body07(target_destination) : "Body Part 07" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body08(target_destination) : "Body Part 08" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body09(target_destination) : "Body Part 09" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body10(target_destination) : "Body Part 10" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body11(target_destination) : "Body Part 11" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body12(target_destination) : "Body Part 12" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body13(target_destination) : "Body Part 13" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body14(target_destination) : "Body Part 14" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body15(target_destination) : "Body Part 15" : "" : "Pick a brush entity (such as func_brush)to be the body group"
	body16(target_destination) : "Body Part 16" : "" : "Pick a brush entity (such as func_brush)to be the body group"
]
@PointClass base(Angles2, Propper) iconsprite("editor/env_physexplosion.vmt") = propper_physgun_interactions :
    "Defines non-standard interactions with the Gravity Gun. Used for physics props only."
[
	preferred_carryAngles(choices) : "Use Angles when carrying" : "0" : "The player will always carry the prop at this entity's Angles2 if possible" =
	[
		0 : "No"
		1 : "Yes"
	]
	stick(choices) : "Stick to walls" : "0" : "" =
	[
		0 : "No"
		1 : "Yes"
	]
	bloodsplat(choices) : "Create blood splatter" : "0" : "" =
	[
		0 : "No"
		1 : "Yes"
	]
	break(choices) : "Always break when launched" : "0" : "" =
	[
		0 : "No"
		1 : "Yes"
	]
	paintsplat(choices) : "Create paint splatter" : "0" : "" =
	[
		0 : "No"
		1 : "Yes"
	]
	impale(choices) : "Impale enemies" : "0" : "" =
	[
		0 : "No"
		1 : "Yes"
	]
	onlaunch(choices) : "Spin on launch?" : "default" : "" =
	[
		"default" : "Random (default behavior)"
		"spin_none" : "no spin"
		"spin_zaxis" : "Spin on z-axis (horizontal)"
	]
	explode_fire(choices) : "Ignite nearby enemies" : "0" : "When this breaks, NPCs such as combine soldiers and zombies will light on fire." =
	[
		0 : "No"
		1 : "Yes"
	]
]
@PointClass base(Propper)  studio("models/editor/cone_helper.mdl") = propper_particles : 
    "Attach a particle emitter to this prop. Does not work with prop_static."
[
	name(string) : "Particle system" : "" : "The name of a particle system. NOT the name of a .pcf file!"
	attachment_type(choices) : "Attachment Type" : "follow_Origin" : "'Spawn at' choices will start the particle system at the prop's position, but if the prop moves, the particle emitter stays in place. Good for short-term effects like explosions" =
	[
		"start_at_Origin" : "Spawn at prop Origin"
		"start_at_attachment" : "Spawn at prop attachment"
		"follow_Origin" : "Follow prop's Origin"
		"follow_attachment" : "Follow prop at attachment"
	]
	attachment_point(string) : "Attachment point" : "" : "The attachment point at which the particle system should spawn. Use a propper_attachment for this."
]
@PointClass base(Propper) iconsprite("editor/multi_manager.vmt") = propper_cables :  
    "Attach a visual cable to the selected prop. Does not work on static props."
[
	StartAttachment(string) : "Cable Start Point" : "" : "The name of a propper_attachment"
	EndAttachment(string) : "Cable End Point" : "" : "The name of a propper_attachment"
	Width(float) : "Width" : 3 : "The width of the cable in units "
	Material(material) : "Cable material" : "" : "The VMT (material) to use. Cable materials are located in 'materials/cables'."
	NumSegments(integer) : "Cable segments" : 4 : "The number of segments in the cable. More segments make the cable more 'smooth'. Should be increased if the cable bends a lot."
	Length(integer) : "Cable Length" : 4 : "The length of cable between the two attachment points. If the length is shorter than the distance between the two points then the cable will remain permanently straight.  Note:	Finding the optimal length between two points can be a frustrating task. Cables can go from super tight to extremely slack within a difference of just 10 units."
]
@PointClass base(Propper) iconsprite("editor/gibshooter.vmt") sphere(fademindist) sphere(fademaxdist) = propper_gibs :
    "When a prop breaks, You can cause one or more custom-made broken pieces to spawn in its place."
[
	model(studio) : "Gib model" : ""
	ragdoll(choices) : "Model Type" : "model" : "If the chosen gib model supports ragdoll physics, Use this setting to enable it." =
	[
		"model" : "Physics"
		"ragdoll" : "Ragdoll"
	]
	debris(choices) : "debris" : "1" : "Debris won't collide with the player or other dynamic objects. Use if the gib is small" =
	[
		0 : "No"
		1 : "Yes"
	]
	burst(integer) : "Burst Strength" : 0 : "The gib will receive a force out from the center of the prop if this is set."
	fadetime(integer) : "Fade away time" : 0 : "The gib will begin to disappear after this many seconds."
	fademindist(integer) : "Min Fade Distance (units)" : 0 : "Gib will begin to disappear at this distance from the player"
	fademaxdist(integer) : "Max Fade Distance (units)" : 0 : "Gib will not render at this distance from the player"
]
@PointClass base(Propper) iconsprite("editor/color_correction.vmt") = propper_skins : 
    "Propper can create alternate skins by replacing a texture that is on your prop. If you have multiple textures on your model that you want to change, you can use this entity more than once."
[
	mat0(material) : "Material to replace" : "" : "Pick a texture that's present in the Original model. This will be skin 0."
	mat1(material) : "Skin 1" : "" : "This texture will replace the Original when you pick skin 1."
	mat2(material) : "Skin 2" : "" : "This texture will replace the Original when you pick skin 2."
	mat3(material) : "Skin 3" : "" : "This texture will replace the Original when you pick skin 3."
	mat4(material) : "Skin 4" : "" : "This texture will replace the Original when you pick skin 4."
	mat5(material) : "Skin 5" : "" : "This texture will replace the Original when you pick skin 5."
	mat6(material) : "Skin 6" : "" : "This texture will replace the Original when you pick skin 6."
	mat7(material) : "Skin 7" : "" : "This texture will replace the Original when you pick skin 7."
	mat8(material) : "Skin 8" : "" : "This texture will replace the Original when you pick skin 8."
	mat9(material) : "Skin 9" : "" : "This texture will replace the Original when you pick skin 9."
	mat10(material) : "Skin 10" : "" : "This texture will replace the Original when you pick skin 10."
	mat11(material) : "Skin 11" : "" : "This texture will replace the Original when you pick skin 11."
	mat12(material) : "Skin 12" : "" : "This texture will replace the Original when you pick skin 12."
	mat13(material) : "Skin 13" : "" : "This texture will replace the Original when you pick skin 13."
	mat14(material) : "Skin 14" : "" : "This texture will replace the Original when you pick skin 14."
]
@SolidClass base(Targetname2, Origin2) = propper_model : 
    "This will create a model when Propper is run."
[
	modelname(string) : "Model Name" : "props/generated_prop"  : "The directory and name of the finished model. Relative to <yourmod>/models"
	materialpath(string) : "Material path" : "models/props/generated_prop" : "Where the model's textures will be. Relative to <yourmod>/materials."
	scale(float) : "Scale" : "1.0" : "Scale the model up or down by this factor."
	surfaceprop(choices) : "Surface property" : "no_decal" : "The physical properties of the model--affects impact sounds and weight for physics props." =
	[
		"no_decal" : "no_decal" 
		"boulder" : "boulder"
		"brick" : "brick" 
		"concrete" : "concrete" 
		"concrete_block" : "concrete_block"
		"gravel" : "gravel" 
		"rock" : "rock" 
		"metal" : "metal" 
		"solidmetal" : "solidmetal"
		"metalgrate" : "metalgrate"
		"metalvent" : "metalvent"
		"wood" : "wood" 
		"dirt" : "dirt" 
		"grass" : "grass"
		"gravel" : "gravel" 
		"mud" : "mud" 
		"sand" : "sand"
		"slipperyslime" : "slipperyslime" 
		"ice" : "ice" 
		"snow" : "snow"
		"alienflesh" : "alienflesh" 
		"bloodyflesh" : "bloodyflesh"
		"flesh" : "flesh"
		"foliage" : "foliage" 
		"asphalt" : "asphalt"
		"glass" : "glass"
		"tile" : "tile" 
		"paper" : "paper" 
		"cardboard" : "cardboard" 
		"plaster" : "plaster"
		"plastic" : "plastic" 
		"rubber" : "rubber" 
		"carpet" : "carpet"
		"ceiling_tile" : "ceiling_tile"
		"computer" : "computer"
		"pottery" : "pottery"
	]
	physmodel(target_destination) : "Physics mesh" : "" : "Pick any brush entity (including this one) to represent the physical shape of the model. Leave this field blank for a non-solid model. If you leave this blank while making a physics prop, Propper will automatically use this entity for collisions."
	mass(float) : "Mass" : "0.0" : "Weight of the prop in kg. Enter zero or lower to automatically calculate mass."
	concave(choices) : "Concave collisions" : "1" : "Used to make a concave collision model. If you choose no, the model will be 'shrink-wrapped'." =
	[
		0 : "No"
		1 : "Yes"
	]
	smoothing(choices) : "Smoothing mode" : "1" : "Determines how vertex normals are computed for lighting" =
	[
		0 : "completely faceted"
		1 : "auto-smooth"
		2 : "Use Hammer's smoothing groups only"
	]
	sourcefolder(string) : "Source folder" : "c:/propsource" : "Where you want to keep your .qc and .smd files. The final directory will be <sourcefolder>/<modelname>."
	smoothangle(integer) : "Smoothing threshold" : 45 : "If auto-smooth is enabled, Edges flatter than this angle will appear smooth. Pick from 0 to 180."
	snaptogrid(choices) : "Snap to Hammer grid" : "0" : "Causes every vertex to be snapped to the nearest grid point." =
	[
		0 : "No"
		1 : "Yes"
	]
	weldvertices(float) : "Welding threshold" : ".01" : "Vertices will be snapped together if within this tolerance. A value of 0 is not recommended because there may be visible gaps in the mesh. Larger numbers will merge vertices together, and may be useful for optimizing your model."
	autocenter(choices) : "Auto-Center" : "0" : "The model's Origin point defines how it is lit and is how the prop is positioned in a map. Auto-center moves the model's Origin to the center of its bounding box and is recommended for physics props. For static props, put the Origin somewhere that lets you align the prop easily." =
	[
		0 : "No"
		1 : "Yes"
	]
	mat_nonormal(choices) : "Disable normal mapping" : "0" : "This option removes all bump map info from the converted materials. This is useful if you wish to use -StaticPropLighting to light your props" =
	[
		0 : "No"
		1 : "Yes"
	]
	disp_nowarp(choices) : "Don't warp displacement textures" : "0" : "In Hammer, when you move a displacement point, the texture moves with it. If you pick yes, the texture will not move." =
	[
		0 : "No"
		1 : "Yes"
	]
]
@PointClass base(Origin2, Propper) iconsprite("editor/phys_ballsocket.vmt") = propper_physics : 
    "Propper configuration for physics props. Using this entity will make your prop suitable for use as prop_physics."
[
	base(choices) : "Health preset" : "Stone.Medium" : "Dictates how strong the prop is vs. different weapons." =
	[
		"Cardboard.Small" : "Cardboard.Small"
		"Cardboard.Medium" : "Cardboard.Medium" 
		"Cardboard.Large" : "Cardboard.Large" 
		"Cloth.Small" : "Cloth.Small" 
		"Cloth.Medium" : "Cloth.Medium" 
		"Cloth.Large" : "Cloth.Large" 
		"Wooden.Tiny" : "Wooden.Tiny" 
		"Wooden.Small" : "Wooden.Small" 
		"Wooden.Medium" : "Wooden.Medium" 
		"Wooden.Large" : "Wooden.Large" 
		"Wooden.ExtraLarge" : "Wooden.ExtraLarge" 
		"Wooden.Huge" : "Wooden.Huge" 
		"Stone.Small" : "Stone.Small" 
		"Stone.Medium" : "Stone.Medium" 
		"Stone.Large" : "Stone.Large" 
		"Stone.Huge" : "Stone.Huge" 
		"Glass.Small" : "Glass.Small" 
		"Glass.Window" : "Glass.Window" 
		"Metal.Small" : "Metal.Small" 
		"Metal.Medium" : "Metal.Medium" 
		"Plastic.Small" : "Plastic.Small" 
		"Item.Small" : "Item.Small" 
		"Plastic.Medium" : "Plastic.Medium" 
		"Item.Medium" : "Item.Medium" 
		"Plastic.Large" : "Plastic.Large" 
		"Item.Large" : "Item.Large" 
		"Pottery.Small" : "Pottery.Small" 
		"Pottery.Medium" : "Pottery.Medium" 
		"Pottery.Large" : "Pottery.Large" 
		"Pottery.Huge" : "Pottery.Huge" 
		"Flesh.Tiny" : "Flesh.Tiny" 
		"Flesh.Small" : "Flesh.Small" 
	]
	health(integer) : "Health" : -1 : "Overrides the prop's health. Set this to zero to give infinite health."
	flammable(choices) : "Flammable" : "0" : "Will it burn? Picking this enables the 'ignite' options." =
	[
		0 : "No"
		1 : "Yes"
	]
	ignite_at_half_health(choices) : "Ignite at half-health" : "0" : "Just like those barrels in HL2." =
	[
		0 : "No"
		1 : "Yes"
	]
	explosive_resist(choices) : "Ignite from explosions" : "0" : "Won't break right away if something explodes near it, but will ignite."=
	[
		0 : "No"
		1 : "Yes"
	]
	explosive_damage(float) : "Explode damage" : "0.0" : "Damage to do when breaking"
	explosive_radius(float) : "Explode radius" : "0.0" : "Radius of explosion"
	breakable_model(choices) : "Gibs" : "ConcreteChunks" : "Generic shards to spawn when the prop breaks" =
	[
		"WoodChunks" : "Wood" 
		"GlassChunks" : "Glass"
		"ConcreteChunks" : "Concrete"
		"MetalChunks" : "Metal"
	]
	breakable_count(integer) : "Gib count" : 5 : "How many gibs?"
	breakable_skin(integer) : "Gib skin" : 0 : "Which skin to use on the gib models, if applicable."
]
