nyuuzyou/wikis huggingface dataset:
Triggers

Category:GlossaryCategory:Level DesignCategory:Programming
Triggers are entities which respond to the presence of other entities. Trigger brushes can be created by mappers, while programmers can make anything into a trigger.
== Level Design ==
There are many types of brush entity trigger that can be created from within Hammer; see Special:PrefixIndex/trigger for the complete list. The most common general-purpose ones are , , , and . They all share these properties and outputs:
; : All trigger entities must use this material on all faces. Alternatively, a custom trigger material can be made using .
: 
; Filters: Filter entities can be used to restrict what activates the trigger.
; Filter Flags: There are a series of flags that permit simple filtering without the need of a second entity.
; OnStartTouch
; OnEndTouch
: Outputs called whenever a entity matching all filters enters/leaves the trigger, regardless of whether it has passed any further tests. The entity that entered or left is the .
; OnStartTouchAll
; OnEndTouchAll
: As above, but only called if there are no other (filtered) entities touching the trigger.
; OnTouching
; OnNotTouching
: One of these outputs will be fired in response to the TouchTest input. All triggers support this, but most do not have it listed in their FGD.
; OnTrigger: Fires whenever an entity matches all of the trigger's criteria.
=== See also ===
* Brush entity
* Inputs and Outputs
* Filters
* Special:PrefixIndex/trigger
* showtriggers_toggle, a console command to make trigger brushes visible
== Programming ==
All entities can respond to collisions with other entities (see ). If you want touches without actual collisions, then you have two options:
; SetSolid(SOLID_NONE) and AddSolidFlags(FSOLID_TRIGGER)
: This will cause the entity to receive touches as things pass through it.
; CollisionProp()->UseTriggerBounds(true,iBloatSize)
: This will give the entity a "trigger box" that extends around its bounding box by iBloatSize units in X/Y and (iBloatSize/2) in +Z (-Z remains the same). The trigger box is world aligned and will work regardless of the object's solidity and collision group. It will be visible as a light blue box when the ent_bbox console command is used.
: Valve uses trigger boxes for all pickup items. Their bloat size is 24, a surprisingly large figure.
=== Brush ===
To make a new brush trigger, which tests using the shape of its brush model instead of a bounding box, inherit from CBaseTrigger and call InitTrigger().
Triple Laser

Chamber 20, otherwise known as Triple Laser, is a last test of 4th chapter containing three lasers which the player has to direct through a portal diagonally and perpendicularly into the three corresponding catchers. The test itself has almost every panel portal-able, and is the first test of the Clean theme. The test begins with GLaDOS making a remark about the completely restored function of the facility.
This chamber became very popular in community, mainly by Krzyhau, Ritbulau, Hambrix. They made a videos about that chamber, where they edit the chamber on comedic purposes. This videos title mainly start with "guys something is wrong with my test chamber", "guys something is wrong with ..."
As of 3/18/21, there are approximately 56 Triple Laser variants created by various individuals. (At least 55% of which are by Krzyhau.)
Trouble in Terrorist Town: Level Creation

A Level Creation Guide for 
For general mapping tutorials, see :Category:Level Design
For see here
You need for Trouble in Terrorist Town:
* 
* (Materials, Textures, Models)
== Getting Started ==
* Getting started in the Hammer Editor
== Special Objects ==
* TTT Weapon Placement
* Traitor Tester
* Traitor Doors
* Traitor Traps
Making maps for is essentially the same as creating maps for other games with a few exceptions. TTT has its FGD file available here which includes gamemode-specific entities. Map examples are available at https://www.troubleinterroristtown.com/development/mapping/
== Entities ==
 This entity allows you to give or take credits away from a Detective or Traitor player. 
 
 This entity allows you to correctly attribute damage to the player that activated it. (Traitor traps, etc)
 This entity allows you to display text on the screens of a role, or all players
 This entity allows you to check if the role of the !activator
 This entity allows you to control things related to your map, like player models or prop procession.
Troubleshooting Outputs

==== Viewing Inputs ====
Double click on the Entity that you wish to view the inputs of then navigate
to the "Inputs" tab. Here you will find
Detailed information on every Input your
entity is receiving from other entities.
The "Inputs" tab is very good for troubleshooting; you will make mistakes
occasionally.
<Br />
targetname has further information on connecting entities. 
<Br />
==== I/O Queue ====
At the bottom of the properties window, it shows the outputs from the entity that you're editing. If they have a red cross through them, hammer has detected something wrong with the output, if your output isn't working properly and there isn't a red cross through it, then maybe try changing the parameters of the output.
See Next: Setting up an Output
Category:IO System
True reflections under CSS

Category:Level Design
Using the Source engine, the only way to get real-time reflections is to use the "water" shader (typically used for water textures). Typically, reflections are made possible by cubemaps, which are low-quality and pre-calculated but sufficient for most materials. Cubemaps are not useful for a mirror which requires a real-time reflection. There is a trick, however, that makes it possible to use real-time reflections in a custom material. this technique consists in superimposing (overlaying) 2 shaders: A normal transparent shader and a water shader (for reflections only). This technique is ideal for a floor, but unfortunately cannot be applied to a wall due to an engine limitation with the water shader. The water shader reflects everything in the world except for the player.
This technique is mostly useless since , because it has an entity for real-time reflections which can be applied to a wall: , which uses the LightmappedReflective shader. However, this technique is still useful on as "LightmappedReflective" no longer works after the game uses deferred renderer in later updates.
==How it Works==
You need to use 3 layers of materials:
* Normal material (in alpha) on the surface where players will walk. Optional.
* A material with the Water shader which will show reflections in real time.
* Something to overlay the water material (without this, it will not work properly).
===Material for the Surface===
Create a brush that is 1 hammer unit thick and apply the material to it with alpha. It is important to leave a gap of any width between this material and the water, or the alpha will not work and you will have a kind of blurry effect.
Example :
 LightmappedGeneric
 {
 $alpha 0.6
 $basetexture ...
 }
===Water===
 Water
 {
 %compilewater 1
 $reflecttexture _rt_WaterReflection
 $reflectamount 0.1 // The lower the value, the more reflections you will have.
 $reflecttint "[1 1 1]"
 $normalmap .... // Indicate a texture of solid colors, such as a solid white texture.
 $fogenable 0
 $fogcolor "[1 1 1]"
 %compilepassbullets 1 
 }
The parameter "%compilepassbullets" 1 will make the material unresponsive to external effects, balls and players who step on it will have no effect on it. This setting is essential for CSS, because the balls go through the Blocks, every time you shoot on the ground you will have a SPLASH, which is not realistic. You can also, thanks to this compilation parameter, run on this surface, as on a mirror.
===Covering the Material===
It's pretty important to cover this material, but it doesn't matter how you do it.
==Tutorial==
http://www.interlopers.net/tutorials/19882
==Translation Notes==
I'm going to follow this tutorial to learn how it works, and then rewrite the page in a way that English readers can understand.
Ttt credit adjust

It controls map logic to give or take credits away from a Detective or Traitor player. When activated, it tries to remove (or give) the specified number of credits from the !activator.
A practical example of this entity is to have a Traitor room door that will only open if the activator spends 1 credit. This would be done by having a ttt_traitor_button with logic as follows.
== Keyvalues ==
== Inputs == 
== Outputs ==
Ttt damageowner

This point entity is useful for correctly attributing damage to the player that activated a series of events. Traitor traps are an example of this. If a player activates a traitor trap with this entity set up correctly, then the !activator of the trap will be credited with the kill in the post-round logs. It is worth noting that karma will be correctly adjusted for any damage attributed to this entity. Whatever trigger is used to activate a trap, it is important that it also fires the output to the ttt_damageowner with the input of SetActivatorAsDamageOwner. This means that anybody who takes damage from the target entity will now be taking damage from the !activator.
== Keyvalues ==
== Inputs ==
Ttt logic role

This point entity is used to test the role of the !activator. You set what role to test for. If the !activator of the ttt_logic_role is the specified role, then the entity will fire a OnPass output, if it is not the correct role it will fire OnFail. It is VERY important to note that you do not want to set a button to start the test because that will test whoever presses the button. Instead, use a button to enable a that will in turn fire the test output. This ensures that whoever is in the specific zone is the !activator. It is recommended to use this entity rather than the brush entity , but may not work depending on some tester designs.
== Keyvalues ==
== Inputs ==
== Outputs ==
Turrets

__NOTOC__
All types of turrets.
By default, automatic turrets are enemies of the player. To make turrets player-friendly, use an .
== Turrets ==
Fixed turrets
* : Fixed auto-turret mounted in the floor.
* : Fixed auto-turret mounted in the ceiling.
Movable turrets
* : Tripod-mounted auto-turrets that can be picked up and moved.
== / Turrets ==
* : Tripod-mounted auto-turrets that can be picked up and moved.
* : In ground, one legged.
== Miscellaneous Turrets ==
250px|right
* allows the mapper to place sentry guns a la those of the .
== Usable mounted guns ==
* Tutorial- Shows how to set up dynamic prop guns.
*
Turtle Rock Studios

__NOTOC__
 (also formerly known as Valve South) was founded in March 2002 by Michael Booth, is an independent game developer in the business of creating original entertainment titles and providing consulting services to the digital entertainment industry.
The studio worked in collaboration with Valve, producing titles such as , , as well as several maps for , and co-developing and with Valve.
== History ==
Turtle Rock Studios announced on March 16, 2006 they would be working with Valve on a "Source project", later to be named , which would be utilizing Valve's Source Engine and Steam. Press release.
On January 10th, 2008, Turtle Rock was acquired by Valve and renamed as Valve South. You can read the Press Release here.
Since March 2010, Turtle Rock Studios was split from Valve and later in 2021, TRS's parent company, Slamfire Inc., was acquired by Tencent. Since then, they have developed and released games such as Evolve, and Back 4 Blood (which is Left 4 Dead's spiritual successor), both new games received mixed reviews from fans, and between mixed to mostly positive reviews from critics.
== Products ==
Year	Product Name 	Notes
2003	 	Co-developed with Ritual.
2004	 	
2008	 	As Valve South
2009	: The Passing 	
2010	Left 4 Dead: The SacrificeLeft 4 Dead 2: The Sacrifice	As Turtle Rock Studios (split from Valve)
2011	Leap Sheep! 	
2015	Evolve 	
2016	Evolve Stage 2Face Your Fears 	
2017	The Well 	
2019	Face Your Fears 2Journey of the Gods 	
2021	Back 4 Blood 	Spiritual successor to and .
== Maps ==
Year	Map
2006	cs_militia
2005	de_nuke
2005	de_inferno
2005	de_train
2005	de_prodigy
2005	de_tides
2004	cs_office
== Counter-Strike Bot ==
Turtle Rock Studios is responsible for the artificial intelligence behind CS_Bot, used in and . CS_Bot was later updated by for and , and was used as the basis for NextBots in the , , and .
== External links ==
* Turtle Rock Studios website
* Official forums for the bot system (down) - Archived version.
== See also ==
* Organization category
Category:Developer Corporations
Category:Valve
Twister

is a program that can generate displacements that would usually take an extremely long time, or just be impossible to create in Hammer.
==Features==
*Generate different shapes out of displacements • The program can generate twists, curves, corners, circles, cones, domes and spheres
*Generate from image maps • The program can generate displacements from noise maps and heightmaps
* Convert displacement to brushwork (useful for porting to another engine, such as GoldSrc)
==External links==
* Homepage (archived)
* User guide (archived)
Category:Third_Party_Tools
Category:Displacements
USS Darkstar

USS Darkstar follows a scientist on a deepspace scientific mission aboard an interstellar spacecraft. When an experiment goes awry, the player has to defend against aliens. This mod was featured by the PC Gamer magazine on its demo CD in 2001.
== Overview ==
USS Darkstar is a Half-Life mod created by Neil Manke and his team, largely based in Canada. The mod follows Gordon Freeman and several other scientists on board USS Darkstar a large exploratory starship that resembles the Nostromo from the movie Alien. Very early in the game, a security guard is injured on an Away Mission to a nearby planet and is taken into the sickbay.
When the scientists are operating on the guard, a headcrab bursts from his chest cavity (coupled with the Nostromo look of the Darkstar, this was most likely also inspired by Alien) forcing the scientists to activate the incinerator. The flame jet kills the headcrab but also detonates a fuel canister, which creates a chain reaction. 
This causes a surge which badly damages the Darkstar's main computer, deactivating all the forcefields and letting loose the aliens. The aliens kill most of the crew, but Freeman manages to reach an escape pod and escape the ship, shortly before it explodes. The game ends with Freeman's pod heading towards the nearby planet, pursued by a large alien vessel.
At least one other scientist also survived the destruction of the Darkstar. During Freeman's entering of the labs, the escape pod elevator can be seen through the window, down which the scientist is heading. When reaching the escape pod launch room, one escape pod has already been launched.
USS Darkstar was "selected by Valve Software for presentation at the first Half-Life ModExpo at San Francisco in 1999."—John "Chief" Phillips, 01/02/06, Black Widow Games: Five Days of Fear (Day 1)
== See also ==
* 
* They Hunger: Lost Souls
== External links ==
* Official website
* Download
===Reviews===
* Ten Four Maps review
* Hangar 16 review
* VeNgEaNcE's House Of Horrors
* --The Maniacal Realm-- USS Darkstar Review
* Hornetking UK Half-Life
* IRONPLANET
* Quake Map Hotel
* Level of The Week - USS Darkstar - Planet Half-Life
Category:Single Player Mods
UTF-16

UTF-16 is a way to encode Unicode characters in 16-bit (2 byte) chunks. Characters using UTF-16 encoding can be stored in wchar_t variables or arrays, or wstring objects, but may not handle surrogates properly if mishandled.
== See also ==
* UTF-16 article on Wikipedia
* Joel Spolsky's "The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)"
Category:Glossary
UTF-8

UTF-8 is a way to encode Unicode text in 8-bit chunks. It has the advantage of being backwards-compatible with ASCII, but will use two to four bytes to encode higher Unicode characters such as Cyrillic or Japanese text. (That is, any code point of greater value than 127 will require at least two bytes.)
== See also ==
Joel Spolsky's "The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!)"
Category:Glossary
UTIL AngleDiff

UTIL_AngleDiff is a UTIL provided in the Source code for finding the difference between two values, clamped between -180° and 180°.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Returns the difference between two values as a float. 
// Input : destAngle - Value "B" to compare against
// Input : srcAngle - Value "A" to compare with
// Output : float - Difference between the two values, interpreted as an angle
//-----------------------------------------------------------------------------
inline float UTIL_AngleDiff( float destAngle, float srcAngle )
== Examples ==
//Restricts a value from going too far beyond another one.
//This is used in the jeep to keep you from looking too far left/right, etc.
float flAngleDiff = AngleDiff( vecViewAngles.y, vehicleEyeAngles.y );
flAngleDiff = clamp( flAngleDiff, pYawBounds[0], pYawBounds[1] );
vecViewAngles.y = vehicleEyeAngles.y + flAngleDiff;
Category:Programming
Category:UTIL
UTIL AngleDistance

UTIL_AngleDistance does a similar thing to UTIL_AngleDiff, but does not clamp in a range from -180° to 180°. Instead, it brings them up to 360° closer to these values.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Returns the difference between two values as a float. 
// Input : next - Value "B" to compare against
// Input : cur - Value "A" to compare with
// Output : float - Difference between the two values, interpreted as an angle
//-----------------------------------------------------------------------------
inline float UTIL_AngleDistance( float next, float cur )
== Examples ==
//Note! In this example they used the UNCLAMPED version (UTIL_AngleDistance is UNCLAMPED),
//Instead of the pre-clamped version (UTIL_AngleDiff)
//They then clamp the value. This is only provided for documentation's sake
//But it's probably just easier to use UTIL_AngleDiff which will always be between -180 and 180.
// Move toward target at rate or less
float distX = UTIL_AngleDistance( angles.x, GetLocalAngles().x );
vecAngVel.x = distX * 10;
vecAngVel.x = clamp( vecAngVel.x, -m_pitchRate, m_pitchRate );
SetLocalAngularVelocity( vecAngVel );
Category:Programming
Category:UTIL
UTIL AngleMod

UTIL_AngleMod is a UTIL provided in the source code for normalizing a floating point angle, so that any returned angle is between 0 and 359.999. Function is mostly just a complicated way of writing 
return angle % 360.0;
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: Returns a floating point normalized angle between 0 and 359.999
// Input : Angle that might need to be normalized
// Output : float - A normalized angle value
//-----------------------------------------------------------------------------
inline float UTIL_AngleMod( float a )
== Examples ==
GetMotor()->SetIdealYaw( UTIL_AngleMod( flCurrentYaw + flDeltaYaw ) );
Category:Programming
UTIL Approach

UTIL_Approach is a UTIL provided in the Source code for 'approaching' a target value. It is useful for creating non-linear movement when turning.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : target - Target value to reach
// Input : value - Current value
// Input : speed - Speed at which to approach the target value
// Output : float - Current value? //TODO: Check
//-----------------------------------------------------------------------------
inline float UTIL_Approach( float target, float value, float speed )
{
	return Approach( target, value, speed );
}
== Examples ==
m_flTurn = UTIL_Approach( m_flMaxTurnSpeed, m_flTurn, flTurnAdd * gpGlobals->frametime );
SetLocalAngularVelocity( QAngle(0,m_flTurn * 10,0) );
//Gently flatten out the pitch from the starting pitch/yaw
m_existPitch = UTIL_Approach( 0.0, m_existPitch, 1 );
QAngle angles = GetLocalAngles();
angles.x = m_existPitch + ( sin( gpGlobals->curtime * 3.5f ) * DROPSHIP_MAX_LAND_TILT );
//Approach 'zero' or neutral on a PoseParameter.
//SetPoseParameter takes PoseParameter, and the value to be at.
SetPoseParameter( m_poseHead_Yaw, UTIL_Approach( 0, yaw, 10 ) );
Category:Programming
Category:UTIL
UTIL ApproachAngle

UTIL_ApproachAngle is a UTIL provided in the Source code for 'approaching' a target value, as an angle. It is useful for creating non-linear movement when turning.
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : target - Target value to reach
// Input : value - Current value
// Input : speed - Speed at which to approach the target value
// Output : float - Current value? //TODO: Check
//-----------------------------------------------------------------------------
inline float UTIL_ApproachAngle( float target, float value, float speed )
{
	return ApproachAngle( target, value, speed );
}
== Examples ==
//Called every frame in a Think function, approaches the new angle at a rate of MAX_WIND_CHANGE (5.0f)
m_nDirCurrent = UTIL_ApproachAngle( m_nDirTarget, m_nDirCurrent, MAX_WIND_CHANGE );
m_goalHeadCorrection.x = UTIL_Approach( m_goalHeadCorrection.x * s0 + vTargetAngles.x * s1, m_goalHeadCorrection.x, 10.0 );
Category:Programming
Category:UTIL
UTIL Beam

is a UTIL wrapper function for .
void UTIL_Beam( Vector &Start, Vector &End, int nModelIndex, int nHaloIndex, unsigned char FrameStart, unsigned char FrameRate, float Life, unsigned char Width, unsigned char EndWidth, unsigned char FadeLength, unsigned char Noise, unsigned char Red, unsigned char Green, unsigned char Blue, unsigned char Brightness, unsigned char Speed);
Category:UTIL
UTIL BloodDecalTrace

UTIL_BloodDecalTrace is a UTIL provided in the Source code for creating Blood decals. Currently, this only directly supports Red blood ( bloodColor = 0, or BLOOD_COLOR_RED), which will create a red blood decal. Any other blood color will result in a yellow blood decal. 
== Usage ==
//-----------------------------------------------------------------------------
// Purpose: 
// 
// Input : trace_t - *pTrace | trace_t class that has been configured with a trace.
// Input : int - bloodColor | Type of blood to create. Only supports 0, otherwise yellow blood
// Output : 
//-----------------------------------------------------------------------------
void UTIL_BloodDecalTrace( trace_t *pTrace, int bloodColor )
== Examples ==
trace_t	tr;	
CBasePlayer *pPlayer;
pPlayer = ToBasePlayer( GetOwnerEntity() );
Vector forward;
AngleVectors( GetAbsAngles(), &forward );
UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + forward * 128, 
	MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, & tr);
//Now that we have a trace set up, create a BloodDecal at the end.
UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED );
//Create 8 yellow blood decals within +/- 16 units of the object.
//This is from the npc_antliongrub.
trace_t tr;
Vector	vecStart;
Vector	vecTraceDir;
//GetVectors appears to take world-relative values
//And make them relative to the entity.
//So in this case, it's changing the value of vecTraceDir to
//be 'straight up' from the entity.
GetVectors( NULL, NULL, &vecTraceDir );
//Makes all of the values negative -- in this case
//It's taking the current "up" vector, and turning it into
//a "down" vector, or 'below' the entity.
vecTraceDir.Negate(); 
//Create 8 random decals that are within +/- 16 units of the 'down' vector we just got.
for ( int i = 0 ; i < 8; i++ )
{
	vecStart.x = vecOrigin.x + random->RandomFloat( -16.0f, 16.0f );
	vecStart.y = vecOrigin.y + random->RandomFloat( -16.0f, 16.0f );
	vecStart.z = vecOrigin.z + 4;
	UTIL_TraceLine( vecStart, vecStart + ( vecTraceDir * (5*12) ), MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
	if ( tr.fraction != 1.0 )
	{
		UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_YELLOW );
	}
}
Category:Programming
Category:UTIL