nyuuzyou/wikis huggingface dataset:
WiseDoorBreak

==Introduction==
In this project we are going to create a door that will function they way you would expect and can be destroyed.
==Creation==
The first thing is to determine the size of the door you need. With Prop doors, (Model doors), I place the door and then build the wall around it. This door allows us a bit more flexibility in that we need only be concerned with the player height/width and the appearance we desire.
Create a brush with the nodraw texture: 4 x 48 x 109 units (The wall is 4 units thick). Now let’s texture our brush based door.
Door faces: wood\wooddoor008a
Door edges: plaster\plasterwall012a
Use the Face Edit tool to apply any textures you like for your door. Some textures, filter with keyword “door”, have door handles and windows, of course these are not functional. You can create your own handle from small brushes, just for appearance. Now select the door and press then convert your door to . Give it a name, and check the Use Opens flag.
Create another brush with the nodraw texture the same size as your door except for the width which will be one unit thicker than the door on both faces. 6 x 48 x 109 units. Tie this brush to and move it so it covers your door. (The door will be inside of it.)
Set these properties:
*Disable Shadows: Yes
*Parent: door1
*Prop Data: None
*Strength: 90
*Material Type: Wood
*Disable Receiving Shadows: Yes
Now set these outputs for the func_breakable:
	OnBreak	door1	Kill 		0.00	No
	OnUser1	door1	Toggle		0.00	No
This is but one method for creating a door that can be destroyed; I believe this may is best.
When the player presses the Use key our door will either open or close.
If the door gets a lot of damage it will break apart and then it will be gone.
==See also==
*Example VMF
*Example VMF backup
*WiseDoor
*WiseSlidingDoor
*WiseOneWayDoor
WiseElec

==Introduction==
In this tutorial, we will create an obstacle such as a fence, in which it is electrified and can be toggled by a trigger. You can any as one but as a recommendation, using a model prop for this makes it easy. For the tutorial we will use a railing from Half-Life 2 (see right). 
For the purpose of this tutorial the rail obstacle is initially electrified, since that is what many will require. For that purpose, the example map shows that it can be disabled by standing on a small red carpet and re-enabled by standing on a small green carpet (the carpets are not shown in screenshots).
When a player "touches" the fence in this tutorial while it is electrified there will be sparks, and the player will get blown back a few feet.
trigger_hurt is used to start off the series of events when the player touches it. Additionally, it outputs to entities to create the "blow back" of the player and sparks. These are: one env_physexplosion, eight env_sparks, one trigger_push, and one logic_timer to lend some logic.
It is recommended that you have basic understanding of the Hammer editor, and with placing a entity and the manipulation of such.
==Creation==
So let's get going on creating that electrified obstacle.
First, we should find a spot in our level or map in which we think we should place one. As with Half-Life 2 players solve "puzzles" to continue progressing the game - and this can be thought as of such.
Next, we will make the obstacle that will be "electrified". This can be a prop_static or a displacement. It is recommended to use something like a fence, or a railing (shown in the first screenshot), since it logical item to a player. You could just as easily use motion enabled entity types. Remember the player has to get around the obstacle.
Now, we will create the entities for the electrified fence.
Most people will require a way of shutting the "electricity" off to the obstacle. Follow these steps:
==See also==
*Example VMF
*Example VMF backup
*Another archive of the VMF on the wiki
WiseExplosion

This tutorial is not meant to be used as is, although it could be. What I’ve tried to do is create a small example for more than one request I received.
Here’s the effect we’re going to create:
#Voice in background yells “Ah crap, Incoming!”
#Sound of incoming Mortar fire.
#Large explosion with ground shake and player damage.
#Resulting fire and smoke, fire will eventually go out.
To trigger this series of events I’m going to use a placed in front of where the player will start. This part could be done with a switch or any other method with outputs. I’ve placed a brush on the ground in front of the player to indicate where the trigger is once the map loads.
These are the outputs for the trigger_multiple:(Porter's note: The vmf doesn't have any trigger in it...?)
You are probably aware that we could use this same method and our trigger could be a plus our trigger_multiple has a very useful property Delay Before Reset that could be set to any convenient number.
Lets add our ground shake ():
*Amplitude: 14
*Effect Radius: 500
*Duration: 1
*Frequency: 1
*Flags: Global Shake, Physics
Our explosion in this example is a quick group of 5 explosions, 4 of which are and 1 is an . The combination of these makes our mortar landing very realistic.
For the 4 env_explosions:
*Name: Explode1 (All 4)
*Magnitude: 100
*Render: Additive
*Flags: No Damage, Repeatable, Random Orientation
The one env_physexplosion:
*Name: Explosion01
*Magnitude: 500
This is a shot form Hammer of our and you can see the layout of the explosions and fire.(Porter's note: Again, no triggers inside the VMF for some reason.)
Our trigger_hurt:
*Start Disabled: Yes
*Damage: 80
*Damage cap: 20
*Damage Type: Blast
*Damage Model: Normal
*Flags: Clients only
Our trigger_hurt is used for the proximity of the Mortar blast and we’re using outputs in our initial trigger to turn this damage on and off for a half second, just long enough to catch a player standing in the wrong place.
The 5 fire balls are not needed, our explosions will have a lot of fire in them but I’m using them in this tutorial to show how they can be triggered.
*Class: env_fire
*Name: Fire01
*Start Disabled: No
*Duration: 30
*Size: I varied these, 55-65
*Attack: Varied, .05-3
*Type: Natural
*Ignition Point: 10 (Not needed for this)
*Damage Scale: 1.0
I’ve used three sounds for this, the explosions have their own sounds.
Download the vmf file for this tutorial, below, and play with these settings. There are other effects you could add to this such as a dust ball but with the 5 explosions used in this example the smoke, embers, sparks and sounds are all there. Places this could be used in a map are open to your imagination but you could create both serious and humorous effects. For example, download my Vending Console example and change it so each time the Saw blades come out they are launched with a big boom, kinda like in the cartoons.
==See also==
*Example VMF
*Example VMF backup
WiseGarageDoor01

==Introduction==
 is a real time saver for a project like this one. I’ve created a barn and have considered how tall the large front door will need to be by deciding how many parts I want it to be, for this project the door has 5 moving parts all the same size. Another consideration is the amount of space needed to hide the door once it goes up. The brush above the 5 moving brushes is taller than they are individually.
==Creation==
To create the door I created 5 brushes the correct width and all 40 units tall. All 5 together will occupy the 200 units of open space allotted for the door. Each of the 5 brushes is converted into func_movelinear one at a time by selected each of them individually and then pressing , choosing func_movelinear and finally clicking on Apply.
All 5 are given the same name, door01. This keeps us from having to have 5 times the outputs. 4 of the 5 have nearly the same settings but the bottom brush needs to have an additional sound, when it stops, and it needs to move 2 units less so there is a small lip once the 5 brushes have opened.
Each of the 5 func_movelinear brushes has the same Move Direction, -90 0 0. They will all move up, together. Since each of them is 40 units tall they need to move at least 40 units, plus the height of each brush above them. i.e. 40, 80, 120, 160 and 198. The bottom brush moves 198 instead of 200 so we can have that lip when they’re open.
I’ve added a Block damage of 100 to each of the 5. For all of them the Start sound is doors\door_metal_gate_move1.wav. Only the bottom one has a Stop sound which is doors\default_stop.wav. The Speed for each is 60. And the Start position is 0.
In this project I've used entities to open and close the door. The same thing can be done with buttons. That’s all there is to it. You can make a door like this in less than 15 minutes.
==See also==
*Example VMF
*Example VMF backup
WiseGateLockMath

==Introduction==
Counting Whacks? Yep.
For any of you not familiar with that term it’s the action taken when someone gives you a good hit with something, you just receive a good Whack. 
This project is an adaptation of WiseGateLock.
An AKG forum member requested a tutorial on making it harder for the Player to break the lock. As you probably know most of the tutorials are the results of requests.
In this project I’m using a to count how many times the lock received damage, or Whacks. I could have simply created a method to control the Health but I believe this method is best. 
==Creation==
Everything is the same as the previous tutorial except the lock was changed from to (models\props_wasteland\prison_padlock001a.mdl)
Why the need for prop_physics_override? With prop_physics_override, and , we have additional properties. Each of the override prop types has their own qualities, for this project prop_physics_override is perfect.
Changing the lock to prop_physics_override is simple. Select it and press or double-click on it. Once the properties dialog is open change the Class to prop_physics_override.
Now in the properties dialog make sure the Health is set to 0. In the flags put a checkmark in Don’t take physics damage.
Now add a math_counter to the project. (Don’t be afraid of these entities. They have the word "Math" in their name but they are really simple to use.)
Once the math_counter entity has been added change the properties:
*Name: HitCounter
*Initial Value: 0
*Minimum legal value: 0
*Maximum legal value: 5
We’ll create two outputs from the math_counter.
	OnHitMax	locklatch	Kill 		0.00	Yes
	OnHitMax	lockgate 	Break		0.00	Yes
The Outputs from the Lock need to be changed from the previous project.
*Name: lockgate
*World Model: models/props_wasteland/prison_padlock001a.mdl
*Health: 0
*Flags: Don’t take physics damage
	OnHealthChanged	HitCounter	Add 	1	0.00	No
	OnBreak 	sparkgate 	SparkOnce	 	0.10	Yes
	OnBreak 	socketgate	Kill 	1	0.20	Yes
	OnBreak 	gate01 	Unlock 	 	0.30	Yes
Notice with the many Outputs only one of them isn’t Checked for Only Once. We need the Output to the math_counter to be fired 5 times. One the fifth Output the math_counter will break the lock. When the Lock breaks it will fire off a series of Outputs.
In this project I’ve also added a Player Clip in one corner of the fence. This was to illustrate how you can keep the Player in the area you want them. 
==See also==
*Example VMF
*Example VMF backup
WiseGravity

==Introduction==
I’ve combined two applications in this project as a result of different requests.
#When the player walks onto the grate it will launch them high into the air.
#Until they return to the first part of the map there will be low gravity.
#When they return to that first part gravity will be restored.
The 3 main entities in this project are:
# (A trigger volume that changes the gravity on any entity that touches it.)
# (A trigger volume that pushes entities that touch it.)
# (A brush entity that moves linearly along a given distance, in a given direction.)
If the player were to step in the lower gravity trigger area and jump they would be able to jump very high. This is not only because of the lower gravity but also from the help the player got from the trigger_push.
In this project I’ve added a func_movelinear to simulate a bounce effect like those from the original Half-Life. There are lots of ways you can create this effect and in HL1 a was used.
As you noticed func_movelinear is another brush based entity. The grated area in this project is mostly , only the grating is func_movelinear. It’s so quick and smooth the player won’t notice much else about it.
==Creation==
Settings for the func_movelinear:
*Name: DoorFloor
*Move Direction: -90 0 0
*Start Position: 0
*Speed: 600
*Moving Distance: 10
*Block Damage: 0
*StartSound: Weapon_Crossbow.BoltHitBody
*StopSound: Bounce.Flesh
Settings for the trigger_push:
*Start Disabled: No
*Push Direction: -90 0 0
*Speed of Push: 2600
*Flags: Everything
	OnStartTouch	DoorFloor	Open 		0.00	No
	OnStartTouch	light01 	TurnOn 		0.00	No
	OnStartTouch	DoorFloor	Close 		0.07	No
	OnEndTouch 	light01 	TurnOff		0.00	No
Notice how the lights are turned on and off by the trigger_push. This really saves you a lot of work and creates oodles of possibilities.
Settings for the trigger_gravity enabling low gravity:
*Start Disabled: No
*Gravity: 0.1
*Flags: Everything
The trigger for normal gravity is the same except Gravity is 1.
==See also==
*Example VMF
*Example VMF backup
WiseHDR

(Porter's note: About half of the original tutorial by wisemx was left out of this port because it was basically an exact copy of the HDR Lighting Basics page.)
== Example==
Let’s examine the Source SDK HDR example map from step by step. Even if you don't have DOD:S this file is part of the updated Source SDK, you can open it in Hammer with the CS:S parameters. The map is .
:
*Pitch Yaw Roll: 0 165 0
*Pitch: -40
*Brightness: 250 241 192 600
*Ambient: 209 227 237 200
*BrightnessHDR: 250 241 192 500
*AmbientHDR: 209 227 237 200
Skybox Texture Name: sdk_sky_example_hdr
:
*Name: tonemap
:This entity is give a name so it can be called via inputs. There are 9 inputs in the example env_tonemap_controller. Three of the inputs set the initial HDR exposures when the map starts via a logic_auto. The remaining 6 Inputs are 2 groups of 3 Inputs from triggers.
:
	OnMapSpawn	tonemap	SetAutoExposureMax	2 	0.00	No
	OnMapSpawn	tonemap	SetAutoExposureMin	.8 	0.00	No
	OnMapSpawn	tonemap	SetBloomScale 	1.2	0.00	No
The trigger_multiple entites are not needed but are used to illustrate how you can control the HDR exposure during the game.
Walking into the sample building will trigger these:
	OnMapSpawn	tonemap	SetAutoExposureMax	5	0.00	No
	OnMapSpawn	tonemap	SetAutoExposureMin	3	0.00	No
	OnMapSpawn	tonemap	SetBloomScale 	2	0.00	No
Walking out of the sample building will trigger these:
	OnMapSpawn	tonemap	SetAutoExposureMax	2 	0.00	No
	OnMapSpawn	tonemap	SetAutoExposureMin	.8	0.00	No
	OnMapSpawn	tonemap	SetBloomScale 	1 	0.00	No
Notice the height of the inside the sample building. This will often be important when you build cubemaps with the console command in relation to the height of windows for example.
Lastly, notice the dev reflectivity materials are used. These are great tools for both testing and achieving lighting effects. You can for example use the material dev/reflectivity_30 on a for a light-at-the-end-of-the-tunnel effect, even without HDR enabled.
==Final Notes==
Open the DOD:S sample map sdk_dod_flash. (In the same folder as the HDR sample.) Notice the 15 entities used in this map. These are used to change the lighting origin of a . To use these simply place an info_lighting in the spot where you want to change the lighting origin for a prop_static. Then in that prop_static set the name of the info_lighting in the Lighting Origin property. Also notice there are only 3 inputs in the env_tonemap_controller for this map. The Exposure Max, Min and Bloom Scale are all set once when the map spawns.
WiseHammer

==Introduction==
The purpose of this document is to save you some time by eliminating the need to run the SDK Launcher to load Hammer 4 with the proper game parameters.
When you load the SDK Launcher you have the option, in the bottom section of the SDK Launcher illustrated below, of setting the game parameter before launching Hammer.
This will make environmental settings for you and make sure that things like the map source folder, material folders, and prop folders are correct along with the compile line options you will need.
You can however create Desktop Shortcuts and Taskbar Quick Launch shortcuts.
Let's get started...
==Creation==
Right-click on your Desktop and create a new Shortcut.
Enter the following line in the Location input area: (Shown below)
%sourcesdk%\bin\hammer.exe
Click Next, Give your Shortcut a name and click Finish.
Now Right-click on the newly created Shortcut and then select Properties.
The Start In area should already have the correct path, i.e.
The Target area will need to be changed.
First find the complete path to the Source game you want to create this Shortcut for.
I’ll use HL2 for this example, the others are done the same way.
On my system, the full path to the HL2 folder we’ll need is:
We’re going to alter the current information listed in the Target area like this:
%sourcesdk%\bin\hammer.exe -game "c:\program files\steam\steamapps\AKG\half-life 2\hl2"
Once you’ve done this, with the quotation marks as illustrated, click OK.
Try your new Shortcut now.
Test to see if the information you set is correct by using File Open once Hammer loads.
You’re good to go if you see the map source files for the game parameter you set.
If not close Hammer and re-check your path then edit the information in the Shortcut.
Shown below are the paths for each of the Source mods.
===:===
%sourcesdk%\bin\hammer.exe -game "c:\program files\steam\steamapps\AKG\half-life 2\hl2"
'''
===:===
%sourcesdk%\bin\hammer.exe -game "C:\Program Files\Steam\SteamApps\AKG\counter-strike source\cstrike"
'''
===:===
%sourcesdk%\bin\hammer.exe -game "C:\Program Files\Steam\SteamApps\AKG\day of defeat source\dod"
'''
===:===
%sourcesdk%\bin\hammer.exe -game "C:\Program Files\Steam\SteamApps\AKG\half-life 2 deathmatch\hl2mp"
'''
WiseHangLamp

In this tutorial I’m going to illustrate two different types of Swinging Lights, one for HL2/HL2DM and one for CS:S. 
==HL2/HL2DM==
Create a :
*Name: Lamp01
*World Model: models/props_c17/lamp_standard_off01.mdl
*Disable Shadows: Yes
*Flags, Prevent Pickup'
Place this prop exactly where you want it.
Create a on top of the lamp.
*Name: KeyFrame01
*Parent: Lamp01
Create a on the ceiling, or whatever the top most point is.
*Next KeyFrame: KeyFrame01
*Width: 1
*Texture Scale: 1
Create a at the top most spot. This will be the joint/hinge.
*Entity 1: Lamp01
Place a inside the lamp, where the light will originate from.
*Parent: Lamp01
*Pitch Yaw Roll: 90 0 0
*Adjust the Length, Width and Color to your liking.
*Flags: Start On, No Dynamic Light
When put together all of the entities above will look like this in Hammer:
https://web.archive.org/web/20060106223658im_/http://www.akilling.org:80/akg/assets/wiseSwingLamp01.jpg
And this is the way it will look in the game:
https://web.archive.org/web/20060106223115im_/http://www.akilling.org:80/akg/assets/wiseSwingLamp02.jpg
This lamp will now swing when hit. The light will move with the lamp. Since we flagged No Dynamic Light the lamp will not shine light onto objects. You can uncheck that flag but allowing dynamic light may hurt game performance. Experiment with that setting, for performance and lighting effects. Dynamic light is great but it can cause strange effects in your maps.
==CS:S==
Create a and place it where you want.
*Name: Lamp01
*World Model: models/props/de_prodigy/lighthanging.mdl
*Disable shadows: Yes
Create a at the ceiling, or top most “hinge” point.
*Entity 1: Lamp01
Place a inside the lamp, where the light will originate from.
*Parent: Lamp01
*Pitch Yaw Roll: 90 0 0
*Adjust the Length, Width and Color to your liking.
*Flags: Start On, No Dynamic Light
The concerns with dynamic light are the same as in HL2/HL2DM above. This is the way your completed lamp will look in Hammer.
https://web.archive.org/web/20060227005041im_/http://www.akilling.org:80/akg/assets/wiseSwingLamp03.jpg
And this is the way it will look in the game.
https://web.archive.org/web/20060106225321im_/http://www.akilling.org:80/akg/assets/wiseSwingLamp04.jpg
==See also==
*Example VMF
*Example VMF backup
WiseLadder

==Introduction==
In this tutorial we’re going to:
#Use a static ladder model from HL2.
#Turn it into a ladder that players and NPCs can use.
==Creation==
The first thing I’ve done is place the model for the ladder I’m going to use. As you probably know it’s only good for looking at once we place it, players won’t be able to use it yet. When you use models for your ladders make them prop_static and adjust the properties setting Collisions to Use VPhysics if you want to use physics for the ladder as it looks, Use Bounding Box' if you want to block off the area around the ladder (the yellow frame you see when the model is selected in Hammer) or best yet for most ladder models Not Solid which means the player and other physics can go right through it.
The following are the settings for the prop_static I’m using for this tutorial:
*World Model: models/props_c17/metalladder002.mdl
*Collisions: Use VPhysics
*Disable Shadows: No
We could create this same ladder without any model at all, for example to allow players to climb up the side of trash dumpsters.
The entity we are going to create next is a func_useableladder.
#Click the Hammer Entity tool.
#With your 2D view ports place the func_useableladder where you want it.
#You should see a large red rectangle.
#Expand one of the small white circles in the 2D view ports until you have stretched out the func_useableladder. The size of your ladder will be determined by the two red blocks. Make the bottom block flush with the ground and raise the top block above the highest stepping plane if you want the player to be able to face the ladder and climb back down, lower it some if you want to force the player to turn and climb down, up to you.
Now we need to place a few info_ladder_dismount entities. These are used to create enter and exit points for your ladder. Use the Entity tool and place these at each end of your ladder where the player will be entering and exiting.
Give your func_useableladder a name, like Ladder1. Select all your info_ladder_dismounts and set LadderName to Ladder1, the name of our func_useableladder. (Porter's note: You only need to set this if there's other ladders very closeby.)
Run your map and go test the new ladder. Your ladder should already be working perfectly with the few steps it took here. Experiment with the placement of your info_ladder_dismounts and the position of your func_useableladder. It really is simple so if you’re having trouble just delete them and start over, it may be easier, especially at times when the points for a func_useableladder can mess up in Hammer, when that happens it may be a lot quicker to recreate them.
Once you’ve created a few HL2 ladders you’ll have the hang of it.
==See also==
*Example VMF
*Example VMF backup