conduit.fgd

// Conduit FGD

//
// worldspawn
//

@SolidClass = worldspawn : "World entity"
[
	message(string) : "Text on entering the world"
	worldtype(choices) : "Ambience" : 0 =
	[
		0 : "Medieval"
		1 : "Metal (runic)"
		2 : "Base"
	]
	sounds(integer) : "CD track to play" : 0
	light(integer) : "Ambient light"
	_sunlight(integer) : "Sunlight"
	_sun_mangle(string) : "Sun mangle (Yaw pitch roll)"
]

//
// base marker definitions
//

@baseclass = Angle [ angle(integer) : "Direction" ]

@baseclass = Appearflags [
	spawnflags(Flags) =
	[
		256 : "Not on Easy" : 0
		512 : "Not on Normal" : 0
		1024 : "Not on Hard" : 0
		2048 : "Not in Deathmatch" : 0
	]
]

@baseclass = Targetname [ targetname(target_source) : "Name" ]
@baseclass = Target [
	target(target_destination) : "Target"
	killtarget(target_destination) : "Killtarget"
]
@baseclass base(Target) = Target2 [
    target2(target_destination) : "Secondary target"
]
@baseclass base(Targetname) = Controller [
    target(target_destination) : "Control target"
]
@baseclass base(Target) = IoVar [
    io_send(integer) : "Value to send on fire" : 0
]
@baseclass base(IoVar, Target2) = TargetVar []

//
// player starts, deathmatch, coop, teleport
//

@baseclass base(Appearflags) size(-16 -16 -24, 16 16 32)
	color(0 255 0) model({ "path": ":progs/player.mdl" }) = PlayerClass []

@PointClass base(PlayerClass) = info_player_start : "Player 1 start" []
@PointClass base(PlayerClass) = info_player_coop : "Player cooperative start" []
@PointClass base(PlayerClass) = info_player_start2 : "Player episode return point" []
@PointClass base(PlayerClass) = info_player_coop2 : "Player cooperative episode return point" []
@PointClass base(PlayerClass) = info_player_deathmatch : "Deathmatch start" []
@PointClass base(PlayerClass) = testplayerstart : "Testing player start" []
@PointClass size(-32 -32 0, 32 32 64) base(PlayerClass, Targetname) = info_teleport_destination : "Teleporter destination" []
@PointClass color(200 150 150) = info_null : "info_null (spotlight target)"
[
	targetname(target_source) : "Name"
]

@PointClass base(Appearflags, TargetVar, Targetname) color(200 150 150) = info_notnull : "Wildcard entity" // I love you
[
	use(string) : "self.use"
	think(string) : "self.think"
	nextthink(integer) : "nextthink"
	noise(string) : "noise"
	touch(string) : "self.touch"
]
@PointClass base(Appearflags) = info_intermission : "Intermission camera"
[
	mangle(string) : "Camera angle (Pitch Yaw Roll)"
]

//
// items
//
@baseclass base(Appearflags, TargetVar, Targetname) = Item
[
	message(string) : "Message"
	target(string) : "Target"
	killtarget(string) : "Killtarget"
	delay(float) : "Delay" : "0"
]
@baseclass size(0 0 0, 32 32 56) color(80 0 200) base(Item) = Ammo
[
	spawnflags(flags) =
	[
		1 : "Large box" : 0
	]
]

@PointClass
    base(Ammo)
    model(
        {{
            spawnflags & 1 ->   ":maps/b_batt1.bsp",
                                ":maps/b_batt0.bsp"
        }}
    ) =
    item_cells : "Thunderbolt ammo" []

@PointClass
    base(Ammo)
    model(
        {{
            spawnflags & 1 ->   ":maps/b_rock1.bsp",
                                ":maps/b_rock0.bsp"
        }}
    ) =
    item_rockets : "Rockets" []

@PointClass
    base(Ammo)
    model(
        {{
            spawnflags & 1 ->   ":maps/b_shell1.bsp",
                                ":maps/b_shell0.bsp"
        }}
    ) = item_shells : "Shells" []

@PointClass
    base(Ammo)
    model(
        {{
            spawnflags & 1 ->   ":maps/b_nail1.bsp",
                                ":maps/b_nail0.bsp"
        }}
    ) = item_spikes : "Nailgun/Perforator ammo" []

@PointClass
    size(0 0 0, 32 32 56)
    base(Appearflags)
    model(
        {{
            spawnflags & 2 ->   ":maps/b_bh100.bsp",
            spawnflags & 1 ->   ":maps/b_bh10.bsp",
                                ":maps/b_bh25.bsp"
        }}
    ) =
    item_health : "Health pack"
[
	spawnflags(flags) =
	[
		1 : "Rotten" : 0
		2 : "Megahealth" : 0
	]
]

@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/suit.mdl" }) =
	item_artifact_envirosuit : "Environmental protection suit" []
@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/quaddama.mdl" }) =
	item_artifact_super_damage : "Quad damage" []
@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/invulner.mdl" }) =
	item_artifact_invulnerability : "Pentagram of Protection" []
@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/invisibl.mdl" }) =
	item_artifact_invisibility : "Ring of Shadows" []

@PointClass size(-16 -16 0, 16 16 56) base(Item, Appearflags) model({ "path": ":progs/armor.mdl", "skin": 2 }) =
	item_armorInv : "Red armor (200%)" []
@PointClass size(-16 -16 0, 16 16 56) base(Item, Appearflags) model({ "path": ":progs/armor.mdl", "skin": 1 }) =
	item_armor2 : "Yellow armor (150%)" []
@PointClass size(-16 -16 0, 16 16 56) base(Item, Appearflags) model({ "path": ":progs/armor.mdl" }) =
	item_armor1 : "Green armor (100%)" []
@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/w_s_key.mdl" }) =
	item_key1 : "Silver key" []
@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/w_g_key.mdl" }) =
	item_key2 : "Gold key" []
@PointClass size(-16 -16 -24, 16 16 32) base(Item, Appearflags) model({ "path": ":progs/end1.mdl" }) =
	item_sigil : "Sigil"
[
	spawnflags(Flags) =
	[
		1 : "Episode 1" : 1
		2 : "Episode 2" : 0
		4 : "Episode 3" : 0
		8 : "Episode 4" : 0
	]
]

//
// weapons
//

@baseclass size(-16 -16 0, 16 16 56) color(0 0 200) base(Item, Appearflags) = Weapon []

@PointClass base(Weapon) model({ "path": ":progs/g_shot.mdl" }) = weapon_supershotgun : "Double-barrelled shotgun" []
@PointClass base(Weapon) model({ "path": ":progs/g_nail.mdl" }) = weapon_nailgun : "Nailgun" []
@PointClass base(Weapon) model({ "path": ":progs/g_nail2.mdl" }) = weapon_supernailgun : "Super nailgun" []
@PointClass base(Weapon) model({ "path": ":progs/g_rock.mdl" }) = weapon_grenadelauncher : "Grenade launcher" []
@PointClass base(Weapon) model({ "path": ":progs/g_rock2.mdl" }) = weapon_rocketlauncher : "Rocket launcher" []
@PointClass base(Weapon) model({ "path": ":progs/g_light.mdl" }) = weapon_lightning : "Thunderbolt" []

//
// Squads
//

@baseclass base(TargetVar) = SquadMate
[
    squad(string) : "Squad name"
]

//
// monsters
//

@baseclass base(Angle, Appearflags, TargetVar, Targetname, SquadMate) color(220 0 0) = Monster
[
	spawnflags(Flags) =
	[
		1 : "Ambush" : 0
	]
]

@PointClass base(Monster) size(-16 -16 -24, 16 16 40) model({ "path": ":progs/soldier.mdl" }) = monster_army : "Grunt" []
@PointClass base(Monster) size(-32 -32 -24, 32 32 40) model({ "path": ":progs/dog.mdl" }) = monster_dog : "Nasty Doggie" []
@PointClass base(Monster) size(-32 -32 -24, 32 32 64) model({ "path": ":progs/ogre.mdl" }) = monster_ogre : "Ogre" []
@PointClass base(Monster) size(-32 -32 -24, 32 32 64) model({ "path": ":progs/ogre.mdl" }) = monster_ogre_marksman : "Ogre marksman" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 40) model({ "path": ":progs/knight.mdl" }) = monster_knight : "Knight" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 40) model({ "path": ":progs/hknight.mdl" }) = monster_hell_knight : "Hell knight" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 40) model({ "path": ":progs/wizard.mdl" }) = monster_wizard : "Scrag" []
@PointClass base(Monster) size(-32 -32 -24, 32 32 64) model({ "path": ":progs/demon.mdl" }) = monster_demon1 : "Fiend" []
@PointClass base(Monster) size(-32 -32 -24, 32 32 64) model({ "path": ":progs/shambler.mdl" }) = monster_shambler : "Shambler" []
@PointClass base(Monster) size(-128 -128 -24, 128 128 256) model({ "path": ":progs/boss.mdl" }) = monster_boss : "Chthon" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 40) model({ "path": ":progs/enforcer.mdl" }) = monster_enforcer : "Enforcer" []
@PointClass base(Monster) size(-32 -32 -24, 32 32 64) model({ "path": ":progs/shalrath.mdl" }) = monster_shalrath : "Vore" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 24) model({ "path": ":progs/tarbaby.mdl" }) = monster_tarbaby : "Spawn" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 24) model({ "path": ":progs/fish.mdl" }) = monster_fish : "Rotfish" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 32) model({ "path": ":progs/oldone.mdl" }) = monster_oldone : "Shub-Niggurath" []
@PointClass base(Monster) size(-16 -16 -24, 16 16 32) model({ "path": ":progs/zombie.mdl" }) = monster_zombie : "Zombie"
[
	spawnflags(Flags) =
	[
		1 : "Crucified" : 0
		2 : "Ambush" : 0
	]
]

//
// lights
//

@baseclass color(255 255 40) = Light [
	light(integer) : "Brightness" : 300
	wait(integer) : "Fade distance multiplier" : 1
	delay(choices) : "Attenuation" =
	[
		0 : "Linear falloff (Default)"
		1 : "Inverse distance falloff"
		2 : "Inverse distance squared"
		3 : "No falloff"
		4 : "Local minlight"
		5 : "Inverse distance squared B"
	]
	mangle(string) : "Spotlight angle"
	style(Choices) : "Appearance" : 0 =
	[
		0 : "Normal"
		10: "Fluorescent flicker"
		2 : "Slow, strong pulse"
		11: "Slow pulse, noblack"
		5 : "Gentle pulse"
		1 : "Flicker A"
		6 : "Flicker B"
		3 : "Candle A"
		7 : "Candle B"
		8 : "Candle C"
		4 : "Fast strobe"
		9 : "Slow strobe"
	]
]

@PointClass size(-8 -8 -8, 8 8 8) base(Light, Target, Targetname) =
	light : "Invisible light source"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-8 -8 -8, 8 8 8) base(Light, Target, Targetname) =
	light_fluoro : "Fluorescent light"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-8 -8 -8, 8 8 8) base(Light, Target, Targetname) =
	light_fluorospark : "Sparking fluorescent light"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-8 -8 -8, 8 8 8) base(Appearflags, Light, Target, Targetname) =
	light_globe : "Globe light"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-8 -8 -12, 8 8 20) base(Appearflags, Light, Target, Targetname) model({ "path": ":progs/flame2.mdl" }) =
	light_flame_large_yellow : "Large yellow flame"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-4 -4 -12, 4 4 20) base(Appearflags, Light, Target, Targetname) model({ "path": ":progs/flame2.mdl" }) =
	light_flame_small_yellow : "Small yellow flame"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-4 -4 -12, 4 4 20) base(Appearflags, Light, Target, Targetname) model({ "path": ":progs/flame2.mdl" }) =
	light_flame_small_white : "Small white flame"
	[
		spawnflags(Flags) = [ 1 : "Start off" : 0 ]
	]
@PointClass size(-4 -4 -12, 4 4 20) base(Appearflags, Light, Target, Targetname) model({ "path": ":progs/flame.mdl" }) =
	light_torch_small_walltorch : "Small walltorch" []

//
// misc
//

@SolidClass base(Appearflags) = func_illusionary : "Static nonsolid model"  []

@PointClass base(Appearflags) color(0 150 220) = air_bubbles : "Air bubbles" []
@PointClass base(Appearflags, Targetname) =
	event_lightning : "Chthon's lightning" []
@PointClass base(Appearflags) model({ "path": ":progs/lavaball.mdl" }) = misc_fireball : "Small fireball"
	[ speed(integer) : "Speed" : 40 ]
@PointClass base(Appearflags, TargetVar) size(0 0 0, 32 32 64) model({ "path": ":maps/b_explob.bsp" }) = misc_explobox : "Large exploding container" []
@PointClass base(Appearflags, TargetVar) size(0 0 0, 32 32 32) model({ "path": ":maps/b_exbox2.bsp" }) = misc_explobox2 : "Small exploding container" []
@PointClass base(Appearflags) size(-8 -8 -8, 8 8 8) model({ "path": ":progs/teleport.mdl" }) = misc_teleporttrain : "Flying teleporter destination"
[
	target(string) : "First stop target"
	targetname(target_source) : "Name"
]
@PointClass base(Appearflags, Targetname) color(220 150 150) = trap_spikeshooter : "Triggered shooter"
[
	spawnflags(Flags) =
	[
		1 : "Spike" : 0
		2 : "Laser" : 0
	]
]
@PointClass base(Appearflags) color(220 150 150) = trap_shooter : "Continuous shooter"
[
	nextthink(integer) : "Delay before first spike"
	wait(integer) : "Delay between spikes"
	spawnflags(Flags) =
	[
		1 : "Spike" : 0
		2 : "Laser" : 0
	]
]

@SolidClass = func_group : "Group of brushes for in-editor use" []
@SolidClass = func_detail : "Group of brushes for certain compilers" []
@SolidClass = func_detail_illusionary : "func_detail variant with no collision (players / monsters / gunfire) and doesn't split world faces." []
@SolidClass = func_detail_wall : "func_detail variant that doesn't split world faces." []

//
// ambient sounds
//

@PointClass base(Appearflags) color(150 0 150) = ambient_drip : "Dripping sound" []
@PointClass base(Appearflags) color(150 0 150) = ambient_drone : "Engine/machinery sound" []
@PointClass base(Appearflags) color(150 0 150) = ambient_comp_hum : "Computer background sounds" []
@PointClass base(Appearflags) color(150 0 150) = ambient_flouro_buzz : "Fluorescent buzzing sound" []
@PointClass base(Appearflags) color(150 0 150) = ambient_light_buzz : "Buzzing sound from light" []
@PointClass base(Appearflags) color(150 0 150) = ambient_suck_wind : "Wind sound" []
@PointClass base(Appearflags) color(150 0 150) = ambient_swamp1 : "Frogs croaking" []
@PointClass base(Appearflags) color(150 0 150) = ambient_swamp2 : "Frogs croaking B" []
@PointClass base(Appearflags) color(150 0 150) = ambient_thunder : "Thunder sound" []

//
// moving things
//


@SolidClass base(Angle, Appearflags, Targetname, TargetVar) = func_door : "Basic door"
[
	speed(integer) : "Speed" : 100
	sounds(choices) : "Sound" : 0 =
	[
        	0: "Silent"
		1: "Stone"
		2: "Machine"
		3: "Stone Chain"
		4: "Screechy Metal"
	]
    noise1(string) : "Stop sound override"
    noise2(string) : "Move sound override"
    noise3(string) : "Locked sound override"
    noise4(string) : "Key-use sound override"
	wait(float) : "Wait before close" : "3"
    delay(float) : "Delay before trigger" : "0"
	lip(integer) : "Lip" : 8
	dmg(integer) : "Damage inflicted when blocked" : 2
	message(string) : "Message if touched"
	health(integer) : "Health (shootable)" : 0
    squad(string) : "Explicitly link doors" : ""
    trig_override(target_source) : "Override trigger"
	spawnflags(flags) =
	[
		1 : "Starts Open" : 0
		4 : "Don't link" : 0
		8 : "Gold Key required" : 0
        	16: "Silver Key required" : 0
        	32: "Toggle" : 0
        64: "Don't allow player to open" : 0
	]
]

@SolidClass base(Appearflags, Targetname, TargetVar) = func_door_secret : "Secret door"
[
	angle(integer) : "Direction of second move"
	t_width(integer) : "First move length"
	t_length(integer) : "Second move length"
	dmg(integer) : "Damage when blocked" : 2
	wait(string) : "Wait before close" : "2"
	sounds(choices) : "Sounds" : 3 =
	[
		1: "Medieval"
		2: "Metal"
		3: "Base"
	]
	message(string) : "Message"
	spawnflags(flags) =
	[
		1 : "Open once" : 0
		2 : "Move left first" : 0
		4 : "Move down first" : 0
		8 : "Not shootable" : 0
        16 : "Always shootable" : 0
	]
]

@SolidClass base(Appearflags, Targetname) = func_wall : "Wall, starts animation when triggered (if supporting texture)" []


@SolidClass base(Angle, Appearflags, Targetname, TargetVar) = func_button : "Button"
[
	speed(integer) : "Speed" : 40
	lip(integer) : "Lip" : 4
	health(integer) : "Health (shootable)"
	sounds(choices) : "Sounds" =
	[
		0 : "Steam metal"
		1 : "Wooden clunk"
		2 : "Metallic clink"
		3 : "In-out"
	]
	wait(string) : "Wait before reset" : "1"
	delay(float) : "Delay before trigger" : "0"
	message(string) : "Message"
]

@SolidClass base(Appearflags, Targetname) = func_train : "Moving platform"
[
	sounds(choices) : "Sound" : 1 =
	[
		0: "Silent"
		1: "Ratchet Metal"
	]
	speed(integer) : "Speed (units per second)" : 64
	target(target_source) : "Target to start at"
	dmg(integer) : "Damage on block" : 2
]

@PointClass base(Appearflags, Targetname) size(16 16 16) color(0 255 255) =
	path_corner : "Waypoint for platforms and monsters"
[
	target(target_source) : "Next target"
	wait(float) : "How long to pause at corner, -1 = forever" : "0"
    spawnflags(Flags) =
    [
        1 : "Run to" : 0
    ]
]

@SolidClass base(Appearflags, Targetname) = func_plat : "Elevator"
[
	spawnflags(Flags) =
	[
		1 : "Low trigger volume" : 0
	]
	speed(integer) : "Speed" : 150
	height(integer) : "Travel altitude (can be negative)" : 0
    trig_override(target_source) : "Override trigger"
	sounds(choices) : "Sound" : 1 =
	[
		0: "None"
		1: "Base fast"
		2: "Chain Slow"
	]
]

@SolidClass base(Appearflags) = func_episodegate : "Episode Gate"
[
	spawnflags(Flags) =
	[
		1 : "Episode 1" : 1
		2 : "Episode 2" : 0
		4 : "Episode 3" : 0
		8 : "Episode 4" : 0
	]
]

@SolidClass base(Appearflags) = func_bossgate : "Boss gate" []

//
// triggers
//

@baseclass base(Appearflags, Target, Targetname) = Trigger
[
    target2(target_destination) : "Secondary target"
	sounds(choices) : "Sound style" : 0 =
	[
		0 : "None/Use noise"
		1 : "Secret sound"
		2 : "Beep beep"
		3 : "Large switch"
	]
    noise(string) : "Path to sound"
	delay(float) : "Delay before trigger" : "0"
	message(string) : "Message"
    gflags(Flags) =
    [
        1 : "Broadcast" : 0
    ]
]

@SolidClass base(Trigger, IoVar) = trigger_changelevel : "Trigger: Change level"
[
	map(string) : "Next map"
	target(target_destination) : "Target"
	spawnflags(flags) =
	[
		1: "No intermission" : 0
	]
]

@SolidClass base(Trigger, IoVar) = trigger_once : "Trigger: Activate once"
[
	health(integer) : "Health (shootable)"
	spawnflags(flags) = [
        1 : "Not touchable" : 0
        4 : "Start inactive" : 0
    ]
]
@SolidClass base(Trigger, IoVar) = trigger_multiple : "Trigger: Activate multiple"
[
	wait(string) : "Wait before reset" : "0.2"
	health(integer) : "Health (shootable)"
	spawnflags(flags) = [
        1 : "Not touchable" : 0
        4 : "Start inactive" : 0
    ]
]
@SolidClass base(Trigger, IoVar) = trigger_onlyregistered : "Trigger: Registered only"
[
	spawnflags(flags) = [ 1: "Not touchable" : 0 ]
]
@SolidClass base(Trigger, IoVar) = trigger_secret : "Trigger: Secret"
[
	sounds(choices) : "Sound" : 1 =
	[
		1 : "Secret sound"
		2 : "Beep beep"
	]
	spawnflags(flags) = [
        1 : "Not touchable" : 0
        4 : "Start inactive" : 0
    ]
]

@SolidClass base(Appearflags, TargetVar, Targetname) = trigger_teleport : "Trigger: Teleporter"
[
	spawnflags(Flags) =
	[
		1 : "Player only" : 0
		2 : "Silent" : 0
        4 : "Monster only" : 0
        8 : "Don't play effect" : 0
	]
]

@SolidClass base(Appearflags, Target, Targetname) = trigger_setskill : "Trigger: Set skill"
[
	message(choices) : "Skill to change to" : 1 =
	[
        -1 : "Use received"
        0 : "Easy"
        1 : "Medium"
        2 : "Hard"
        3 : "Nightmare!"
	]
]
@PointClass base(Trigger) = trigger_relay : "Trigger: Relay"
[
]
@PointClass base(Trigger) = trigger_toggle : "Trigger: Toggle between 0 and 1"
[
    io_send(integer) : "Initial state" : 0
]
@PointClass base(Trigger) = trigger_repeat : "Trigger: Repeat"
[
    count(integer) : "Count" : 1
    wait(float) : "Wait before refire" : "0.2"
    spawnflags(flags) =
    [
        1 : "Count down" : 0
    ]
]
@PointClass base(Trigger, IoVar) = math_var : "Trigger: Send provided value"
[]
@PointClass base(Appearflags, TargetVar) = trigger_init : "Trigger: Fire after map spawn"
[
    delay(float) : "Time after spawn to fire"
    style(choices) : "Value to send" : 0 =
    [
        0 : "Default"
        1 : "Skill"
        2 : "Map global variable"
    ]
]
@PointClass base(Appearflags, Targetname) = dbg_io : "Debug: Print received value"
[
    message(string) : "Prefix to print with value"
    gflags(flags) =
    [
        1 : "Broadcast" : 0
    ]
]
@SolidClass base(Angle, Appearflags, Targetname, Target2) = trigger_monsterjump : "Trigger: Monster jump"
[
	speed(integer) : "Jump Speed" : 200
	height(integer) : "Jump Height" : 200
    spawnflags(flags) =
    [
        4 : "Start inactive"
    ]
]
@PointClass base(Appearflags, TargetVar, Targetname) = trigger_counter : "Trigger: Counter"
[
	spawnflags(flags) = [ 1: "No Message" : 0 ]
	count(integer) : "Count before trigger" : 2
	delay(float) : "Delay before trigger" : "0"
	message(string) : "Message"
]
@SolidClass base(Angle, Appearflags, Targetname) = trigger_push : "Trigger: Push"
[
	spawnflags(flags) = [ 1: "Push once" : 0 ]
	speed(integer) : "Speed" : 1000
]
@SolidClass  base(Appearflags, Targetname) = trigger_hurt : "Trigger: Hurt"
[
	dmg(integer) : "Damage per second" : 5
]
@PointClass size(16 16 16) = misc_noisemaker : "Debug entity: continuously plays enforcer sounds" []
@PointClass size(16 16 16) = viewthing : "Debug entity: fake player model" []

@PointClass base(Trigger) = math_op : "Perform op on input, fire as output"
[
    spawnflags(flags) =
    [
        1 : "Reverse operands"
        64 : "Propagate non-reals"
    ]
    style(choices) : "Operator" : 0 =
    [
        0 : "Add"
        1 : "Subtract"
        2 : "Multiply"
        3 : "Divide"
        4 : "Modulus"
        5 : "Round Down"
        6 : "Round Up"
        7 : "Min (Lowest)"
        8 : "Max (Highest)"
        9 : "Is NaN"
        10 : "Is Real"
    ]
    io_arg2(float) : "2nd Operand" : "0"
	delay(float) : "Delay before trigger" : "0"
]

@PointClass base(Appearflags, Target, Targetname) = math_adder : "Add to stored value"
[
    spawnflags(flags) =
    [
        1 : "Use Upper Bound"
        2 : "Use Lower Bound"
        4 : "Fire on change only"
        8 : "Fire on hitting bounds only"
        64 : "Alow non-real inputs"
    ]
    waitmax(float) : "Upper Bound"
    waitmin(float) : "Lower Bound"
    io_send(float) : "Initial value" : "0"
	delay(float) : "Delay before trigger" : "0"
]

@PointClass base(Appearflags, Trigger, IoVar) = math_compare : "Fire given condition"
[
    style(choices) : "Comparison" : 0 =
    [
        0 : "Less than"
        1 : "Less than/equal"
        2 : "Greater than"
        3 : "Greater than/equal"
        4 : "Equal"
        5 : "Not equal"
    ]
    io_arg2(float) : "2nd Operand" : "0"
]

@PointClass base(Appearflags, Controller) = control_vis : "Controls visibility of its target"
[
    spawnflags(flags) =
    [
        1 : "Modify solidity"
    ]
]

@PointClass base(Appearflags, Controller) = control_var : "Controls send value of its target"
[]

@PointClass base(Appearflags, Controller) = control_frame : "Controls frame number of its target"
[]

@PointClass base(Appearflags, Controller) = control_animate : "Animates frame number of its target"
[
    wait(float) : "Frame delay" : "0.1"
    waitmin(integer) : "Starting frame"
    waitmax(integer) : "Ending frame"
    spawnflags(flags) =
    [
        1 : "Start on"
    ]
]

@PointClass base(Appearflags, Controller) = control_operand : "Control second argument of math_op or math_compare"
[]

@baseclass = MoverSounds
[
    sounds(choices) : "Sounds" : 0 =
    [
        0 : "Silent"
        1 : "DOOR Stone"
        2 : "DOOR Machine"
        3 : "DOOR Stone Chain"
        4 : "DOOR Screechy Metal"
        5 : "DOOR/SEC Medieval"
        6 : "DOOR/SEC Metal"
        7 : "DOOR/SEC Base"
        8 : "PLAT Base"
        9 : "PLAT Chain"
        10 : "TRAIN Ratchet"
    ]
    noise1(string) : "Stop noise"
    noise2(string) : "Move noise"
]

@SolidClass base(Appearflags, Targetname, Target, MoverSounds) = func_slider : "Linear moving brush"
[
    speed(float) : "Speed" : "40"
    dmg(float) : "Damage on block" : "2"
    wait(float) : "Wait before changing direction" : "0"
    spawnflags(flags) =
    [
        1 : "Solid"
    ]
    style(choices) : "Damage model" : 0 =
    [
        0 : "Grow"
        1 : "Constant"
        2 : "Crush"
    ]
]

@SolidClass base(Appearflags, Targetname, Target, MoverSounds) = func_meter : "Rotating indicator"
[
    speed(float) : "Speed (deg/s)" : "45"
    angles(string) : "Initial orientation" : "0 0 0"
    mangle(string) : "Final orientation" : "0 0 0"
]

@baseclass color(255 128 0) model({{
    (model != undefined) -> ":" + model,
    undefined
}}) = FxModel
[
    model(string) : "Model filename"
    angles(string) : "Facing"
]

@PointClass base(Appearflags, Targetname, FxModel) = fx_model_toggle : "Toggleable model"
[
    map(string) : "Secondary model filename"
    avelocity(string) : "Angular velocity"
    spawnflags(flags) =
    [
        1 : "Static"
    ]
]

@PointClass base(Appearflags, Targetname, FxModel, MoverSounds) = fx_model_train : "Moving model"
[
    speed(float) : "Speed" : "100"
    noise3(string) : "Rotate sound"
    target(target_destination) : "Destination"
    spawnflags(flags) =
    [
        1 : "Teleport to start"
    ]
]

@SolidClass base(Appearflags, Targetname) = trigger_mosey : "Cause waiting monster to move"
[
    spawnflags(flags) =
    [
        1 : "Toggle"
        2 : "Start On"
    ]
    wait(float) : "Keep trigger active after targetting for this long" : "0.2"
]

@PointClass base(Appearflags, Targetname, SquadMate) = ai_monitor : "Fires when squadmates wake up"
[
]

@PointClass base(Appearflags, Targetname) = ai_bullseye : "Targetted monsters will attack this entity"
[
    target(target_destination) : "Cause this monster to attack us"
]

@PointClass base(Appearflags, Targetname) color(220 0 0) model({{
    (think == "monster_army") -> ":progs/soldier.mdl",
    (think == "monster_boss") -> ":progs/boss.mdl",
    (think == "monster_demon1") -> ":progs/demon.mdl",
    (think == "monster_dog") -> ":progs/dog.mdl",
    (think == "monster_enforcer") -> ":progs/enforcer.mdl",
    (think == "monster_fish") -> ":progs/fish.mdl",
    (think == "monster_hell_knight") -> ":progs/hknight.mdl",
    (think == "monster_knight") -> ":progs/knight.mdl",
    (think == "monster_ogre" || think == "monster_ogre_marksman") -> ":progs/ogre.mdl",
    (think == "monster_oldone") -> ":progs/oldone.mdl",
    (think == "monster_shalrath") -> ":progs/shalrath.mdl",
    (think == "monster_shambler") -> ":progs/shambler.mdl",
    (think == "monster_tarbaby") -> ":progs/tarbaby.mdl",
    (think == "monster_wizard") -> ":progs/wizard.mdl",
    (think == "monster_zombie") -> ":progs/zombie.mdl",
    undefined
}}) size(-32 -32 -24, 32 32 64) = monster_spawner
[
    think(choices) : "Monster classname" =
    [
        "monster_army" : "Grunt"
        "monster_demon1" : "Fiend"
        "monster_dog" : "Dog"
        "monster_enforcer" : "Enforcer"
        "monster_fish" : "Rotfish"
        "monster_hell_knight" : "Death Knight"
        "monster_knight" : "Knight"
        "monster_ogre" : "Ogre"
        "monster_ogre_marksman" : "Ogre Marksman"
        "monster_shalrath" : "Vore"
        "monster_shambler" : "Shambler"
        "monster_tarbaby" : "Spawn"
        "monster_wizard" : "Scrag"
        "monster_zombie" : "Zombie"
    ]
    spawnflags(Flags) =
    [
        1 : "Spawn w/ ambush or crucified (Zombie)" : 0
        2 : "Spawn w/ ambush (Zombie)" : 0
        8 : "No tele-flash" : 0
        16 : "Spawn angry" : 0
    ]
    netname(string) : "Spawned monster's targetname"
    target(string) : "Spawned monster's target"
    io_send(float) : "Spawned monster's send value" : 0
    squad(string) : "Spawned monster's squad name"
    angle(float) : "Spawned monster's direction" : 0
    count(integer) : "Number of monsters that can spawn" : 1
    delay(float) : "Spawned monster's use target delay" : 0
    speed(float) : "Horizontal velocity on spawn" : 0
    height(float) : "Vertical velocity on spawn" : 0
]

@PointClass base(Appearflags, Targetname, Target2) = math_global : "Manipulate map global variable"
[
    style(choices) : "Mode" =
    [
        0 : "Query global & trigger"
        1 : "Store received to global"
        2 : "Add received to  global"
    ]
]

@SolidClass base(Trigger) = trigger_bucket : "Outputs 1 on player entering, -1 on exit"
[
]