nyuuzyou/wikis huggingface dataset:
Push Gameplay

Push gameplay is one of the many types of mapping techniques out there at the moment. The idea is to create an area that forces the player to move forward within the map and causes the area usually not able to be back tracked, preventing the player from reaching previous areas of the map. It is important to make sure that the player understands that it is not necessary to backtrack, otherwise they could possibly be frustrated by thinking they just can't figure out how to get back there.
One of the main ideas is to create an event that "pushes" the player forward. Mainly how you create that event is up to you but here are a few ways that mods and even Valve have implemented into their work.
== Height push ==
One of the most common Push methods encountered is the Height Push. The Height Push forces the player to move or jump off a high point, and land a few feet below. This kind of Push is used most often because it is very easy to implement in a map. Once the player drops off the ledge then the player cannot go back due to the ledge being just a little too high to reach. One map in Half-Life 2 Episode 1 utilizes this method; the player exits an old hospital and drops off a ledge that is about waist high. The player is unable to return to that area because the ledge is too high.
Besides ledges, here are some other ideas of how to enforce a Push using heights.
*Shafts (elevators, mines, etc)
*Ropes and ladders that end before they reach the floor
*A wind-tunnel could push a player up and deny any movement back downward.
Keep in mind that with the new physics-based puzzles that have been introduced since Half-Life 2, players may attempt to create their own path by stacking objects to climb. If you wish to avoid this, carefully plan the available props and/or weapons (such as a gravity gun) accordingly.
== Destruction push ==
Another common Push method involves a disaster or destruction of the path back. In Half-Life 1, this was usually a tunnel caving in or a catwalk breaking. Other ideas include cliff-side paths that crumble beneath the player, outbreaks of fire or other hazards, and indefensible positions coming under heavy assault.
== Combination ==
In Half-Life 2, when the player is cornered by the Metrocops directly before meeting Alyx, he may try to flee back up the stairs he just came down. If this is attempted, the stairs break. While this is mainly a height push, it obviously has a destruction element to it as well. Such combinations of methods do well, as it lessens the player's feeling of being a "rat in a maze".
== Other ==
A few other ideas that have been seen and used.
* One-way teleports
* Doors that close behind the player
* Timed doors that require the player to push a button and then rush to get through in time
* Darkness can occasionally be used as a deterrent
* Greater amounts of tough enemy on one side
Category:Level Design
Push notifications when your compile finishes

Because compiling a map can take multiple hours, it's often necessary to step away from the computer while it's compiling. By following this tutorial, you can get a push notification on your phone when your compile finishes.
This tutorial requires you have AutoHotKey installed and working.
== Setting up Pushbullet ==
In order to get notifications on your phone, we will be using Pushbullet. Install the application on your phone (from the App Store or your phone's equivalent), create an account, and allow it access to notifications.
Next, visit https://www.pushbullet.com/ and sign in. Once you have signed in, select "Settings" on the left, and then press the button labeled "Create Access Token" on the right. Copy the token it provides.
== Creating the AutoHotKey executable ==
Now we need to create the executable that hammer will run. With AutoHotKey installed, right-click in the folder you want to keep the executable in and select New -> Autohotkey script. Name the file compileNotification.ahk.
Open the script (Double-clicking it will run it, right-click it and open with your text editor of choice), delete everything already inside the script, and paste in this code:
PB_Token := "YOUR TOKEN HERE"
PB_Title := "Compile Done"
PB_Message := "Come back!"
MsgBox % PB_PushNote(PB_Token, PB_Title, PB_Message)
PB_PushNote(PB_Token, PB_Title, PB_Message)
{
	WinHTTP := ComObjCreate("WinHTTP.WinHttpRequest.5.1")
	WinHTTP.SetProxy(0)
	WinHTTP.Open("POST", "https://api.pushbullet.com/v2/pushes", 0)
	WinHTTP.SetCredentials(PB_Token, "", 0)
	WinHTTP.SetRequestHeader("Content-Type", "application/json")
	PB_Body := "{""type"": ""note"", ""title"": """ PB_Title """, ""body"": """ PB_Message """}"
	WinHTTP.Send(PB_Body)
	Result := WinHTTP.ResponseText
	Status := WinHTTP.Status
	return Status
}
Exit
Make sure to replace "YOUR TOKEN HERE" with the access token you got from Pushbullet, then save the script and close your text editor.
Finally, right-click on your .ahk file inside the file browser and press "Compile Script". This will take a moment, but once it is done, you will have a file called compileNotification.exe. If you double-click on it to run it, you should get a notification on your phone saying "Compile Done". On your computer, a box should appear saying "200". This means the notification was sent successfully.
Code from https://www.autohotkey.com/boards/viewtopic.php?t=4842
== Adding the script to Hammer ==
Finally, we need to add the executable to Hammer so that it is run when our compilation finishes. Press F9 to open the Run Map window, then select "Expert" to open the expert compile menu. Select the compile type you want to use from the dropdown, then press "New". This will add a new step to the compile. In the "Command" box on the right, provide the path to the executable. This example uses C:\Users\Dashz\Documents\Macros\compileNotification.exe, but you should change it with the path to your executable. You do not need any parameters.
You are all set! Now, when you finish compiling, you will get a notification on your phone.
Category:Tutorials
Pyro vision (shader)

Category:Team Fortress 2 Category:Shaders 
 It is used to replace the normal textures of a map with a simulation similar to the fantasy land shown in the animated short "Meet the Pyro".
Pyro_vision computes the grayscale value of the diffuse color of the original texture and maps it using a special one dimensional texture. It can also project an overlay texture, usually stripes, uniformly in world space.
The Pyro vision shader has 4 effect modes controlled by $EFFECT
Value	Effect
0 	An R&D stage which is not finished.
1 	Handles most of the world and model rendering in pyro land.
2 	Depth of Field blending.
3 	Pyro vignette drawing.
Standard Fields found in other shaders:
Shader	Default Value 	Description
 	"" 	Your diffuse texture.
 	"" 	Second diffuse texture - For two way blends.
 	"" 	Optional modulate texture - For two way blends.
 	"center .5 .5 scale 1 1 rotate 0 translate 0 0"	The transform parameters for blending.
General Fields:
Shader	Default Value	Description
 	1 	Used to specify the effect type.
 	0 	0 if light-map based, 1 if vertex-lit based.
Effect #1 Fields
Shader	Default Value 	Effect.
 	0.0 	Value from 0.0 to 1.0 to blend the diffuse towards solid white.
 	0.0 	Value from 0.0 to 1.0 to blend the light-map towards solid white.
 	1.0 	Raises the gray scale result to this value.
 	"[ 0.0 1.0 ]" 	Performs a smooth step between the two values supplied. Think of this as the min/max sliders on a histogram chart.
 	255.0 	Downscale the result into this many categories. Value is clamped between 1.0 and 255.0.
 	"" 	Specifies a 1D Texture. The resultant gray scale is used as a texture coordinate into this image to get the final color. We generally used the image as a color gradient, but try different patterns or smoothness of gradients for different results.
 	"[ 1.0 1.0 1.0 ]"	If self illumination is specified, this is the tint color for the self illumination.
Optional Stripes
{| class="standard-table"
! Shader !! Default Value !! Effect
|-
| || "" || The texture used to specify the stripe or any other pattern. It uses standard alpha translucency to blend this texture.
|-
| || "[ 0.002 0.002 0.2 ]" || Specifies the x y z world scaling to compute the seamless texture coordinate of the stripe texture.
|-
| || "[ 1.0 1.0 1.0 ]" || The color modulated against the strip texture’s RGB. If you make your strip texture as gray scale, then you can have greater color control by using this field, as well as only needing one texture to create many colors.
|-
| || 0.0 || Interpolates between the lighting intensity of the pixel to full bright based upon this value.
Python Debugging

Often debugging scripting languages means 100's of printfs to work out whats going on how ever for python, you can attach a proper debugger to it and have breakpoints, see variable values and much more. This tutorial assumes you have all ready completed the Adding Python Tutorial and also you have the latest svn checkout (in that tutorial also).
Note: Due to the way debugging works this will only work on a debug build of the source sdk because of security issues.
== Needed Software ==
The debugger that we will be using to day is called Wing IDE. The version you need is the personal one (or pro) as we need the ability to connect remotely to the python instance as its embedded inside the source engine. Now its not free but the amount of effort that it will save you is worth the money. You can also use the trail for 30 days to play around with it if needed.
Make sure you install it once you have downloaded it.
You will also need to install python 2.6.2 as wing ide uses this for a number of things.
== Getting Started ==
=== Wing IDE Setup ===
You will need enable remote debugging in wing for this to work. Goto Preferences (edit menu) --> Debugging --> External/Remote and enable Passive listening
You will also need to copy some files from the wing install into your python scripts folder. Open the Wing Install folder (default is: C:\Program Files (x86)\Wing IDE 3.2) and copy the file wingdbstub.py to your mod/scripts/python folder. You will also need to grab wingdebugpw from c:\Users\${username}\AppData\Roaming\Wing IDE 3 (for xp its c:\Documents and Settings\${username}\Application Data\Wing IDE 3) and copy it to the same folder.
Once that is done edit wingdbstub.py and set kEmbedded to 1.
=== Source SDK Setup ===
In the server project settings you need to add some settings so it compile correctly. You will need to add theses to debug only.
Add these to: Configure properties -> c++ -> Preprocesser -> Preprocesser defines
WINGDBG
Add these to: Configure properties -> Linker -> Input -> Additional Dependencies
winglib_d.lib
== Ready to Rumble ==
Once you have completed the above steps you should be ready to go. Make sure Wing IDE is open (and be nice to load the mod/scripts/python folder) and then run your mod in debug mode from visual studio and it should connect to wing, break on break points and break on python exceptions.
You can tell if SourceSDK is connected to the Wing IDE as the bottom left icon should turn green.
Category:Python
Python TipsAndTricks

Some tips to help you out
== Class Defines ==
If you add no_init to a class define then that class cant be constructed via python. This is good for classes like players, weapons and entitys that have a special method of constuction.
Example:
bp::class_< NoNew >("CantMakeMe", bp::no_init);
A lot of classes in Source are non copyable (i.e. you use pointers to reference them not stack objects) and thus you will need to state that they are non copyable otherwise strange compile errors or run time errors occur. This doesnt mean you cant make multiplie objects in python that point to this, just that boost wont try and copy it in the python bindings.
bp::class_< NoCopy, boost::noncopyable >("BoostCantCopyMe", bp::no_init);
== Function Defines ==
When a function (or member function) your rapping returns a pointer you will have to tell boost how to handle it. If your return a new object, boost needs to know to hang onto and if you return a pointer to an existing object you have to boost to just use it. If you do the latter your python classes shouldnt hold on to the object as boost only ensures its valid for the lifetime of the function call.
Example New Object:
MyClass* pyGetNewClass()
{
 return new MyClass();
}
bp::def("NewClass", pyGetNewClass, bp::return_value_policy<bp::manage_new_object>()); //callee needs to delete it
Example Existing Object:
CBasePlayer* pyGetPlayerByIndex(int index)
{
 return UTIL_PlayerByIndex(index);
}
bp::def("GetPlayerByIndex", pyGetPlayerByIndex, bp::return_value_policy<bp::reference_existing_object>()); //callee doesnt need to delete it
== Function Calls ==
If your passing a pointer to a python function call and you marked the class as non copyable (see above) you will need to wrap it in the function ptr().
Example:
virtual void OnPlayerKilled(CBasePlayer *pVictim, CBasePlayer *pKiller, CBaseEntity *pWeapon)
{
	this->get_override("OnPlayerKilled")(bp::ptr(pVictim), bp::ptr(pKiller), bp::ptr(pWeapon));
}
Category:Python
QAngle

QAngle is a C++ class in Source that represents a three-dimensional extrinsic Tait-Bryan rotations following the right-hand rule, offset from the cardinal Z axis. Each QAngle contains three vec t rotation values: 
== ==
=== X ===
X pitch +down/-up
=== Y ===
Y yaw +left/-right
=== Z ===
Z roll +right/-left
(-45,10,0) means 45° up, 10° left and 0° roll.
== Declaration ==
 QAngle angMyAngle = QAngle(-45,10,0);
* You could also assign to the X, Y and Z member variables separately.
* The prefix ang (or sometimes just a) identifies the variable as an angle.
== Orientation ==
To get a feeling for how a QAngle([X], [Y], [Z]) works, imagine a first-person perspective: 
* Looking down or up corresponds to positive or negative [X]
* Looking left or right corresponds to positive or negative [Y]
* Tilting your head so your right or left ear faces the ground corresponds to positive or negative [Z]
To relate this back to vectors and coordinates: The values of [X], [Y], and [Z] correspond to a clockwise rotation (in degrees) around the absolute axes y, z, and x, respectively. 
"Clockwise rotation" in an axis assumes the viewer is located at the origin looking in the positive direction of said axis.
=== Naming Conventions ===
Different fields use different naming conventions to describe these angles. To clear up any conflicting terms, short explanations are included below. Source Engine seems to draw its lingo from Aerospace Engineering.
Aerospace Engineering
Mathematics
== Converting from Vector ==
As there is no specific datadesc keyfield for angles, one chosen in Hammer will arrive as a vector. Its ordinates will represent degrees of rotation and not coordinates so it must be fixed up before use:
QAngle angMyAngle = QAngle(vecFromHammer.x, vecFromHammer.y, vecFromHammer.z);
// Conversion back to a vector, if required
AngleVectors(angMyAngle, &vecFromHammer);
== Presence ==
* SP 2013 (blob master)
* MP 2013 (blob master)
== See also ==
* Wikipedia:Yaw, pitch, and roll
* getpos
* Vector and Coordinates
* AngleVectors() / VectorAngles()
Category:Source class
Category:Glossary
Category:Variables
QBSP2

Quake Binary Space Partitioning 2, often just shorted to QBSP2, was one of the sets of tools originally shipped with the Half-Life mod tools that packed geometry into a map and swallowed entities into the world. These tools, along with the other three, were kept in until ZHLT obsoleted them with his major fixes to the compile tools. However, this tool still ships with the mod tools.
Category:Half-Life
QC

:For a list of QC commands, see :Category:QC Commands.
:To learn how to compile a model, see Compiling a model.
A QC file is a script which controls the process of "compiling" SMDs into a binary model that can be loaded into a game. 
A QC configures the model's location and name, while SMD files are used to provide geometry, collision meshes and animations, how the model reacts when shot, and so on.
Comments can be ends of lines starting with //, or blocks contained between /* and */. Source additionally supports end of line comments starting with # or ;. 
== Simple example ==
Here is a very simple QC file for a solid model without any animation or special properties (click on each command for details):
 $modelname	"props_sdk\myfirstmodel.mdl"
 $body mybody	"myfirstmodel-ref"
 
 $surfaceprop	combine_metal
 $cdmaterials	"models\props_sdk"
 
 $sequence idle	"myfirstmodel-ref" // no animation wanted, so re-using the reference mesh
 
 $collisionmodel	"myfirstmodel-phys" { $concave }
== File format ==
== Files ==
== See also ==
* :Category:QC Commands
* Compiling a model
* LOD Models
* Prop Types Overview
* Notepad++ VDF languages
* Highlighting and Compiling QCs with ConTEXT
Category:Modeling
Category:Plain text formats
QCSG

Quake Constructive Solid Geometry, often just shorted to QCSG, was one of the sets of tools originally shipped with the Half-Life mod tools that built geometry in a level before it was packed into the BSP. These tools, along with the other three, were kept in until ZHLT obsoleted them with his major fixes to the compile tools. However, this tool still ships with the mod tools.
Category:Half-Life
QC Gen

QC Gen is an Enhanced QC File Generator that helps you build your basic QC File for and with just a few clicks. Created by .
== Features ==
* Supports both Source and GoldSrc Engines
* choose your MDL output Path
* choose your main SMD/DMX file
* choose your main sequence file
* choose your main CD materials/texture path
* choose multiple CD materials/texture paths
* choose muliple bodygroup files
* choose multiple texture group files for your skin family
* choose muliple qci\qc files
* batch import multiple sequence files in a folder
== External Links ==
* Current Stable Release — Version(0.4.2.6)
QRAD

QRAD (short for Quake RADiosity) was one of the sets of tools originally shipped with the Half-Life mod tools to compile radiosity and lightmap data into a map.
This was one of the most bugged tools out of the original sets of tools. ZHLT found that this tool packed the direct lighting data into a map twice resulting in longer compile times. He also found that every PVS required a light_environment (can be only seen in decomplied map files from some games) for lighting an outdoor area, which could be tedious for mappers.
== Trivia ==
* Even through used VRAD (which does not have the PVS issue), when decompiling all the maps or download a leaked VMF version of the map, many maps (atleast prior to 20th anniversary) contains multiple on every PVS.
== See also ==
*VRAD - counterpart.
*VRAD2 & VRAD3 - counterpart.
Category:Half-Life
Category:GoldSrc Glossary
Qlumpy

Qlumpy is an open-source texturing tool created by John Carmack for Quake and modified by Valve for Half-Life. It is capable of creating WAD and LMP files. It is included in Half-Life SDK and Half-Life Texture SDK.
It can be loaded by drag and dropping .ls (stands for QLumpy Script) file or by launching the application with .ls file as an argument.
==Script file==
The script files can be created either by making them manually using a text editor or using makels tool (included in SDK, takes three arguments: directory of BMP files, output WAD name, output .ls name).
===Tokens===
;$SINGLEDEST <directory name>
:Sets a directory of resulting LMP (format: uint32 width, uint32 height, width*height data, uint16 numcolors, byte palette) files.
;$DEST <path to WAD file>
:Sets a path to resulting WAD file.
;$LOAD <path to LMP file>
:Loads source LMP file.
;$LOADBMP <path to BMP file>
:Loads source BMP file.
All paths except $SINGLEDEST and $DEST are absolute.
===Loading images===
To add an image to a script, load it with $LOAD or $LOADBMP, then write the following line:
<filename> <command> <parameters>
===Commands===
====palette====
Creates a gradient palette between two colors. Takes 6 parameters: 3 for startcolor, 3 for endcolor.
====colormap====
Creates colormap.lmp. Takes 2 parameters: levels and fullbrights.
Color maps are used by Quake for lighting information.
It is not used by Half-Life.
====colormap2====
Experimental. Creates colormap.lmp. Takes 3 parameters: range, levels, fullbrights.
Identical to colormap, except it also allows you to specify the range of the lighting, enabling you to specify overbright values.
It is not used by Half-Life.
====qpic====
Simple image RGB image with last color in palette transparent. Takes 4 parameters: x, y, width, height. If a parameter is -1, it will be grabbed from source image.
Used by the "Loading…" text in Half-Life.
====miptex====
Image with mipmaps, like in Half-Life WADs. Size must be multiples of 16. Takes 4 parameters: x, y, width, height. If a parameter is -1, it will be grabbed from source image.
====font====
Fonts. Takes three parameters: height of glyphs, blocks, numrows (-1 automatic). Block format is <starting glyph> <x> <y> <width> <height>.
Crops glyphs between dots with color #254 in palette, #255 is transparent.
Can take infinite amount of blocks. Usually starting glyph for first block is 32, for second it's 160.
Rounds font sizes to 256x and compresses them so they become unrecompilable with Qlumpy.
GoldSrc fonts are incompatible with Quake fonts because Quake uses monospaced 128x128 fonts, while GoldSrc uses 256x fonts with dynamic width and height.
Category:Tools
Qt

Qt is a cross-platform application and UI framework - some tools from utilize Qt.
Valve ships a modified version of Qt, primarily to allow interoperation with the rest of :
* Valve-Modified Qt 5.15.2: Win64 (Source 2 Workshop Tools since March 2021, Dark Mode is available on this version.)
** Win64 - May 2023 Update (compatible with previous 5.15.2 binaries)
* Valve-Modified Qt 4.8.3: Win32 Win64 (Source 2 Workshop Tools released before 2021)
To confirm the version of Qt being used, you can select "About Qt" from the Help menu in the or other tool windows.
List of games and software/tools that use Qt:
*
*
* 
:*
*
*
*
List of games and software/tools that use Qt: 
*
*
* (formerly )
*
*
*
*
:*
:*
:*
:*
:*
:*
:*
:*
== External links ==
*Official Website for Qt
*
Category: Valve Open Source
QtPyHammer (Strubium)

Strubium's QtPyHammer is a modified fork of , an alternative open-source for the written in . This fork adds features that make it a full-fledged editor.
== Features ==
This fork has all the features of .
=== New Features ===
* Map View and Map Operations toolbar (Unfinished)
* New popup system, replacing Python's command line. 
* Texture Browser (Unfinished)
* "Normal" Compile Menu
* Multi-language system
** Support for languages other than English is spotty, but users can submit language translations on the GitHub 
** Supports English (Default and the fallback), Spanish, French, German, and Russian.
** More languages can be added if there is demand
=== Planned Features === 
* 2D View 
* Textured View Mode
* Brush creation and editing 
* Hammer Object Properties dialog properly saving data
* Properties menu 
* "Advanced" Compile Menu
* Edit timeline (Undo, Redo, etc)
== Usage ==
There are no downloads released yet, but you run the program by:
# Downloading the source code from GitHub
# Install all dependencies for environment by using 
# Running with Python installed. 
== Media ==
QPH - GUI.png|The interface of QtPyHammer
QPH - Entity browser.png|Entity Browser dialog box
== See also ==
*
*Lambda Level Editor
*
*
== External links ==
*GitHub Repository