TF2 Deathrun Mapping Basics

Want to make DR maps but don't know where to start? This guide will set you up with the necessities needed to make TF2 DR Maps.

A Brief Introduction

If you came here, you probably played on someone's DR map and wanted to make one of your own. This guide will give you all the tools, apps, strategies and general knowledge you need to make a good Deathrun map.

(This guide is a work in progress, I will gradually build onto this list later on)

The Beginning

First, you will want to start with UEAKCrash's Arena mapping tutorial before you go straight into DR mode. This will give you some footing on how to use Hammer, the editing tool for making maps. I would suggest watching the whole playlist and following along with him since near everything he goes over applies in some ways to Deathrun.

I won't list every video off, so here's his full mapping playlist

You may also want to watch this tutorial about map version naming.
https://www.youtube.com/watch?v=m7YqJ4MyG7w&ab_channel=UEAKCrash
This covers what you should name your maps in the process of creating them.
You can really name them whatever, the basics are:

The name for your map could be what you want it to be, you can always change it later. If you want spaces in between it, use _ underscore for spaces.
Ex: neonoir_impossible
pirate_adventure

Your version number will be the important part of your map name. This will show the difference between old and newer maps

Alpha is for prototyping and there shouldn't be any proper detail because it's most important to get the layout and trap design done first.
Transition to beta when you have play tested the map with people and the layout and traps are mostly where they need to be. Beta is for detailing and for more play testing to fine tune mechanics, difficulty and find bugs.
When you want to release, transition to proper version numbers, but always play test a new version before releasing. Once released, consider using numbers for major releases and letters for minor releases, e.g. 1, 1a, 1b, 2, 2a etc. Major releases should have new or replacement traps or mini games, minor releases should be for bug fixes.
I would advise against using last names like redux, remake and fix as these are overused, can cause confusion and don't mean what people think they mean.

The maximum filename is 31 characters for your map name, and it should not use any upper-case letters because they can crash Linux servers.

Where to put your custom content for your map

A hard part of mapping is figuring out where your maps will go, where to put things like your custom textures you'll want in your map.
https://steamcommunity.com/sharedfiles/filedetails/?id=2216526350
My friend Matty made a good guide on setting up your filing folders and where to put your files.
One thing I would add is somewhere outside of your steam folders, add a folder for mapping programs only. This will be important for the next part when we get applications for mapping.

Mapping Applications

To make a good map, you will need a couple applications to make image/sound media and special compile programs to run your map.

Compiling Maps

• https://compilepal.ruar.ai/
  This is Compilepal, a compiling and wrapping program that will turn your vmf file into a bsp file for running in TF2.
  
  

  Image and Image Editing

• https://gamebanana.com/tools/95
  VTFEdit, an image converter that converts images like pngs and jpegs to vtfs (valve texture files) that you will use in your map.
  
  
• https://gamebanana.com/tools/6541
  SprayMaker5000, a tool that functions the same as VTFEdit, but specializes in making pixel art, and animated textures that aren't conformed to the perfect square size that the other program uses.
  
  
• https://www.getpaint.net/
  Paint.net is an app for editing images like jpegs and pngs, as well as making your own images with them. It's like an advanced version of M.S. Paint.
  
  

  Extracting Maps and Content

  
  
• https://gamebanana.com/tools/26
  GCFscape, a tool for taking textures and other files from a bsp file and converting them to how they were before.
  
  
• https://github.com/ata4/bspsrc/releases
  BSPsrc, a program that converts BSP files to vmf to open in hammer. This is used if you want to look at a map to figure out how it works. NOTE: you need a version of Java to run this program. If you don't have Java downloaded, you can get the latest version here:
  https://www.oracle.com/java/technologies/javase-downloads.html
  
  

  Audio Editing

  
  
• https://www.audacityteam.org/
  Audacity is an audio editing software which you'll need to create and edit sounds you get to put into traps and music for your map.
  
  
• https://goldwave.com/goldwave.php
  Goldwave is also an audio editing software, like Audacity, except it also has features for editing .wav files and placing loop cues in them. This is used for music that you want on a constant loop in your map.
  
  

  Additional Apps

  
  
• https://www.rarlab.com/

winRAR is a tool that can open .rar files. Sometimes you will come across a .rar file when you download maps from gamebanana, and you'll need this to open them.

• https://notepad-plus-plus.org/
  Notepad++ is a bit more complex than normal Notepad, where it can open vmf files and alter outputs by looking at their code. Useful if you want to mass-change a setting for a bunch of entities.
  
  

Making Sections of your Deathrun map

I won't limit your creativity to what you can make your DR map to be, really you can follow what I do or not and make a good map. These are some pointers I came up with so that it looks nice.

Before I make my whole map, I like drawing out what the paths will look like. This way I can make changes early if I don't like something, and I don't have to work hard to undo my work. You would also want to plot out where you would place the traps. Try to place them not too close to each other but not too far apart. If you have some space in the middle, put some decorations or an obstacle course to traverse.

Normally you'd have one spawn area that is linked to the first section somehow. Sometimes this spawn area and the first section are the same section, in a skybox room or closed room from the sky.

It doesn't matter what size the area is, it should be as big as the story (What your map idea/theme) demands. What matters is the width of the course. You can have a huge room over a cavern but the course is still 256 wide because the runners are on a bridge. Certainly the course should try and stick to a similar width often but the surroundings don't need to be limited.

Keep in mind that when the map starts, there will be more red players so the traps and environment should be designed to accommodate them all comfortable, up to 31 players. Leave the narrow places for the end of the map when there are fewest players alive.

Lighting

Lighting functions mostly like lights in real life, so you have to use different kinds of light entities to light your map in the dark sections.
https://developer.valvesoftware.com/wiki/Constant-Linear-Quadratic_Falloff
This talks about the 3 types of lighting you will find in lights, each functioning their won way. Personally I use Quadratic for everything.

There are 2 light entities that I used in my first map, being light and light_spot

Light spreads light everywhere around it in a big circle. It's cool, but it's not cool to use as your only source of light. Since it's light goes everywhere it has this ugly glare it can give off on textures around it. I would only use it on prop lights/vents/areas that you want to have colored one color like in a temple.


Light_spot is where it gets interesting. It's the most common form of lighting and for good reason.
It lights the area it points at in a big spotlight radius, kinda like a flashlight.



The intensity of the light is controlled by the 4th digit group. I believe Light doesn't have a fixed intensity, but on light_spot, kicking up the intensity and cloning it can generate the natural light you want.

func_tracktrains and path_track

I will later on make a guide going into more detail with these Tracktrains, I am not requiring you to read this whole thing, but if you have suggestions or feedback on this section let me know.


Wiki for tracktrains: https://developer.valvesoftware.com/wiki/Func_tracktrain
Wiki for path_tracks: https://developer.valvesoftware.com/wiki/Path_track
https://www.youtube.com/watch?v=wvpwQRlKuHE&t=62s&ab_channel=TopHATTwaffle

These tutorials do a good job of explaining how tracktrains and path_track work, some things that are important to know about them however:

• Each path_track is it's own entity, which means it uses up some of Hammer's edict limitations for TF2. Use them if nesecarry for a trap/section, but if your section has a moving platform up and down, use a Door entity instead.
  
  
• Going backward in a tracktrain may be a bit difficult, as due to source spaghetti it will sometimes freeze up upon trying to go backward. Make sure to set each path_track's New Speed keyvalue to the desired speed your train goes at, so it will simulate going backwards.
  
  
• Alternate path_tracks are a useful tool to make a tracktrain go different directions. To link up a path_track to another using an alt track, list the second path entity in the main path entity's Branch Path keyvalue. Make an output that switches paths to the alternate track (ToggleAlternatePath) so the entities will follow through that track instead of the main one.
  
  
• DO NOT KILL A TRACKTRAIN/PATH_TRACK WHILE A TRACKTRAIN IS RUNNING ON IT. Killing either one is an intentional crash, due to the train not being able to run anywhere and creating an error. (See Optimization/Edicts)
  
  
• If you have any tracktrains that aren't used to be stood on/used by the player, MARK THEM AS PASSABLE IN FLAGS. This will stop the motivator/other tracktrains from colliding with physics objects you have, which could stop the train, causing a crash.

Motivators

Now that you know how tracktrains work, we can talk about the different types of motivators and how to make them work.

The most common type of motivator is the tracktrain kind. This is a prop/brush attached to a moving Tracktrain with a hurt trigger around it. This tracktrain will move through each section killing anyone who tries going back or past it. The best one for maps with a somewhat non-complicated layout.
If the hurt trigger overextends into Death's area, use a filter to filter the hurt affects red only.

You can extend a hurt trigger outside of the map. Just make sure to keep the origin of your trigger (the blue dot) inside the map or it won't work.

If your tracktrain motivator can't reach every area in your map, and players are able to get around it and delay the round, use a couple failsafe hurt triggers around each section to catch anyone behind.


The second kind is the hurt trigger motivator. This is used in dr_neonoir as a "gas" motivator. If the tracktrain motivator's hurt trigger isn't big enough to reach every area, you can fill each section with a low hurt trigger. This will tell players to keep going.

The last kind is the map wipe. This usually comes as the nuclear missile/bomb explosion. (dr_blackmesa, dr_paradoxal) If using the tracktrain or hurt trigger motivators take up too much entities/edicts, one massive instakill hurt trigger around the entire map plus a fade entity will make it look like a missile blew up the map.

The motivator speed should be set to a speed comparable to the average time it takes runners to pass through a section. So if a group of runners take one minute to pass through a section on average, the motivator should be set to a speed that makes it also take one minute to complete the same section. The delay before the motivator is released is also important. If you only release it six minutes after the round has started then its speed won't matter unless it's super fast. Releasing it one minute after the round starts is a good time because it lets you keep the timing of each section tighter

Here is a tutorial by Cream Tea for extra help with them:
https://www.youtube.com/watch?v=wTLlz7c7KCA&list=PLCnp05EO5OIEXvdgxkjzHxuIhQFnt5SoZ&index=7&t=22s&ab_channel=CreamTea

Making Traps

Like in Making Sections, I won't limit your creativity to what you can make your DR map to be, really you can follow what I do or not and make a good map. These are some pointers I came up with so that it looks nice.

Orient your traps around the theme you've chosen your map to be. This means you shouldn't use the same general trap 3 times in a row for 3 traps, and avoid trap ideas that many people have done in the past. Try to make each trap unique from the last, and function differently.

There are a couple types of traps that you can use in your map to make each one different from the last:

• A chance to avoid based on luck (33/33/33 chance of surviving.)
  Keep in mind that if people get caught in the trap, it's a mostly unfair chance of being able to survive due to there only being a 1/3 chance you won't die in the trap.
  
  
• Skill traps (platforming, dodging)
  
• Mental challenges (timing, observation, problem-solving)

Balance out each trap, don't litter the entire deathrun with them. Do each trap in moderation.

Try to sort out the traps as balanced as you can make them, from least to greatest in difficulty to dodge. Don't be the guy to put a super hard trap at the start.

Good maps have smooth difficulty curves from very easy to hard, and it gets harder as the map goes on. This is because people who aren't very good should have the chance to play the map, too, so if they have to go through a hard trap early in the map and they die, and there are easy traps after, they won't get to play them as much.
Personal improvement with completing each trap will make the player feel more accomplished and feel they are getting better at the map with each try.

Platforming in DR

I won't limit your creativity to what you can make your DR map to be, really you can follow what I do or not and make a good map. These are some pointers I came up with so that it looks nice.

Sure, you have Traps, you have some good sections planned, but how can you make the map more replayable? Tougher? That's where our old friend Platforming comes into place.

Platforming is my definition for obstacles/obstacle courses you have to jump/crawl/launch across with skill, luck and timing. They make your map more enjoyable and making it through the obstacles more rewarding.

Here are a couple examples of Platforming that I've seen:

• Disappearing Platforms
  These are platforms that disappear under your feet. The player jumps across 3-4 of these in succession to make it across a large gap.
  
  Cream Tea made a good tutorial on how to make these platforms here:
  https://www.youtube.com/watch?v=pl_nTNgFrF4&ab_channel=CreamTea
  
• Swinging Obstacles
  These are obstacles (boxes, hammers, axes) attached to an axis entity and swing from side to side. The player has to combine speed and timing to make it across a small bridge and dodge the obstacles. The deathrun maps Safety First, Wolfenstein, Egypt, and Crash_bandicoot feature swinging obstacles in them.
  https://www.youtube.com/watch?v=8WzWLpT4bG4&ab_channel=Dr.Face
  
  
• Moving Platforms
  These are platforms that move around in a circle, from side to side, or rotate in some cases. The player has to jump across them and make it to the other side without falling/slipping off. They can be made with func_tracktrains or doors. Outrun, fall_guys, and technoir feature them in their maps.
  
  
  
• Timed Platforming
  This is just normal parkour. Usually you have to jump across from small platforms in either open or closed space. This can be amplified by adding a small motivator to the section, say timed lazers, spikes that will kill you if you aren't quick enough to complete them. Backrooms, Wastelabs, and Dangerzone feature these timed parkour jumps.
  
  
• Air-strafing Jumps
  This is where deathrun separates the boys from the men. If you want to make your map harder to beat, use these in your map for extra challenge. Air-Strafe jumps are hard to beat and require some skill and practice to get the hang of. It involves changing the direction where you jump in mid-air and landing on the other side of the obstacle. A thin platform with unavoidable spikes/walls in the middle is an example of this. The difficulty can be amplified by stretching the walls out further/blocking the view of the other platform. Just know that not too many people can make these complicated jumps, and if you make it too hard to beat, it may draw people away from playing. Neonoir, Stardust and Ignite have these types of jumps.
  
  
• Surfing Platforms
  Like air strafing jumps, Surfing require some skill and practice to get the hang of. It involves sliding down the side of a platform while holding different movement keys to move diagonally. Maps like Remember to use them sparingly and don't overdo it with the surfing. Dangerzone, Ignite and Waterrun use surfing in their maps.
  

You can use your creativity to take an idea like this and make something never seen before. You can make different and new obstacles from building on these ideas.

Blue's Side

The blue's side of deathrun is often an overlooked part of the map. It's the area where Death/Activator/Hale activates the traps to kill the Red team.

Keep the blue side next to where the gameplay area is, if that means directly on the wall next to the gameplay/non player area. Use BlockBullet on the wall for death to see into the gameplay area, but the players won't be able to see him. Blockbullet is transparent and stops bullets/projectiles from going through the wall.

Don't use glass on the death's wall, since it's reflectivity can be distracting to the death's view, especially if the cubemaps break and make the purple missing texture error. (See Cubemaps)

You can have the death's area on the sides of each section, or over the gameplay area.
I recommend sticking to the same side where possible to reduce time needed to readjust rapidly. Overhead is not the best option since it's hard to see the players from an above perspective, so try to go from the sides whenever possible.

Underneath the gameplay area is probably the worst place to put it. You can always alternate which side you use when you make the blue rooms.

The best idea is to use the least amount of trigger_teleports for death as possible, since it can confuse the death where the players are. Try to make hallways/areas with blue with access to as many traps as you can. Use teleports sparingly, but don't be afraid to use them.


(dr_donald_trump)
Indicators where the death teleports are can be subtle like a prop or circle on the ground for example.

Speed Lanes

Speed Lanes are the flat pads that sit in the back of the blue area. The death can run on these to go forward/backward faster to catch more runners.

When making these, just make a block and put a trigger_push above it going straight one way. Aterantively, you can use a func_conveyor (conveyor belt that moves one direction). Try to make the pad low enough that death doesn't have to jump to get on it, and keep the push speed fast but not insanely fast. 500 is the perfect speed I set mine to.

On some maps, there can be 2 speed pads like in dr_bootcamp or dr_steamworks with many traps. I would only do this if you have a ton of traps to go through in one area. Try to make more space between where the death activates the traps and the speed pad.

224 units from the buttons to the speed pad is a good number to use. The distance from the wall to the speed lane needs to be wide enough for the activator to be able to run back and forth between buttons without inadvertently touching the speed lane.

(dr_bootcamp)

Stall Doors/Breakables

There may be a problem where players are able to run through your map too fast. You may not be able to catch up to the speedrunners even with the speed pads. Stall doors are pretty self explanatory, they slow down the player by stalling them behind a slow moving door/big breakable. This is if your map has not enough space between some traps, or if you need it for a trap to work.

In Office, the stall doors take hours to open up, but gives Hale some time to catch up with them if he is working on people in the other traps.

In my map, I use the stall doors as breakable wood. I used it in an explosion trap that was next to the transition to the next area. If hale activates the trap, the explosive barrels blow up the gate consequently.

I also used a wood gate at the end just so other runners that are trying to catch up with the players have time to.

Anything that requires a melee attack can be blocked by other players occupying the same space, because the melee attacks will actually hit other players. (Ex: how players can stand in front of the remote button outside the spawn and not be able to press it.) The simplest solution is to make the breakable wide enough so more players can hit it. If it's a button, making it press on touch would fix the problem.

Use them if needed in your map.

Attributes Trigger

In your map, you may need to figure out a way to cancel out the fall damage they take, since in some areas people may fall and get hurt by fall damage. This can be avoided in some ways, but you can use something called an Attribute trigger. The full name being trigger_add_or_remove_tf_player_attributes.
https://developer.valvesoftware.com/wiki/Trigger_add_or_remove_tf_player_attributes#FGD_Code

I would only suggest using this trigger if it is absolutely necessary for your map theme. If a player drops 256 units they won't take fall damage but any higher than this and they will. You could design your map so that there are two ways down a drop. One of them causes fall damage but is easy or has some benefit, while the other doesn't cause fall damage but is more difficult or doesn't offer any benefit. (Ex: going down a steep hill.)

Fall damage should only be disabled if the runner is forced to drop a great distance by the map, because receiving fall damage would be unfair. Note that attribute triggers don't work in Open Fortress, Garry's Mod or TF2 Classic.

The full FGD has been compiled into one FGD file on the Death Experiments Discord. My friend worMatty made that has the attributes trigger and an entity dissolving trigger. You can download the file from the server here.[cdn.discordapp.com]


In Hammer, go to the Tools tab in the top toolbar, open Options, then in the Game Files area, click Add and add the FGD to it.


Now open it up in your map and create a trigger entity as trigger_add_or_remove_tf_player_attributes. You can find a whole web page of each attribute you want, and using Chrome's search tab, you can find the attribute you want easy.


Setting a damage filter on a player for landing on a surface from high up is how you do it without attributes. It's an older method that will work in other games, and the only down-side is you still hear the bone crunch sound when you land.

When using attributes all you need to do is specify the attribute name and duration. e.g. 'cancel fall damage' and -1 (this duration takes the attribute away from the player when they leave the trigger).

Template Entities

Templates let you spawn the same set of entities over and over again. This is good for stuff that is spawned, starts to move and then is killed a bit later, such as falling debris or trains.
You may not have to use a Template entity in your map, but it's important to know how to use these if you come across a situation when you need them.

point_templates can house up to 16 targetnames inside of it. It can copy the entity selected in it's keyvalues and spawn it at the point_template's position or at hooked env_entity_makers.
(You can also use the wildcard character to include a broader range of targetnames, e.g. my_door_* would include all targetnames beginning with the string up to the asterisk.)


Entity makers work the same as Templates do, except they take a template, and spit it out at it's origin instead of the point_template's. This entity is used if you wanted to take one template, and use it in other places around your map.

I use templates in my map for things like the barrels, carts and boulders. You can combine templates with other things which I won't limit your creativity to. It saves a lot of edicts to just have one template that can spawn others if needed.

In the barrel section, I can make them forcespawn their entities with a timer entity controlling the times they spawn. This works the same way with the riding cart section.

There is a special rule I came up with when using templates. If you need to combine entities that have parents to objects inside your template, use Name Fixup.
Inside the flags in the point_template you use, there is a flag Preserve Entity Names (Don't do name fixup).
If your template doesn't include parented objects inside the template, you don't have to do name fixup, and it can keep the entity names it has. If you have parented entities, use Name Fixup. Name Fixup adds a special indicator to each entity's name so that way hammer doesn't confuse what prop parents to what.

Make sure to keep the template entities in a skybox room seperate from the map, and use Minimum Light Level = .1 in the keyvalue for brushes/entities. This is so the brushes are illuminated evenly all over. Lighting on brushes is from the place they are placed, so it should match up with the places they are moving through.

Cubemaps

Wiki Page: https://developer.valvesoftware.com/wiki/Env_cubemap

Some textures have reflectivity, as in they have a small shine and have small reflections of the world around them. These are made with Cubemaps. Cubemaps are textures that resemble a mapped 3d area in the game. An env_cubemap placed in the map can take pictures of it's surroundings and make a 3d texture while compiling a map. These 3d textures are applied to textures that use cubemaps, like the glass textures or some metal textures.


Not using an env_cubemap can cause error cubemaps to appear on these reflective textures. It may not seem like a bad thing, but it makes the map look ugly with them, and you definitely need them if you want to use water textures on your map because water needs them too.


The minimum amount you need is one env_cubemap, placed somewhere that best shows the area your map will take place in. You can also place multiple cubemaps around your map so all of the reflectives don't go back to that one position. It will look nicer with more cubemaps, but it's qualtity/quality here.

Texture Design

I won't drill you too much on how to make custom textures, these videos best cover them.
https://www.youtube.com/watch?v=lJ3oCs-52_U&ab_channel=TopHATTwaffle
https://www.youtube.com/watch?v=6BBq-bQJCHs&ab_channel=3kliksphilip

Here's some of the footnotes I'll add to them to help you out,

• VMT's are the thing that you'll need to make the vtf show up in Hammer. You can open it up with Notepad and put whatever custom Properties into it you need including stuff like transparency and reflectivity. Check Auto Create VMT when you save a VTF file to your map files folder, so it will make one with it.
  
  
• "$translucent" "1" allows for pixels of varying opacity, so you can have smooth edges, but you can't overlap translucent faces without the game getting confused about how to sort them (display one on top of the other). $alphatest ("$alphatest" 1) fixes that problem but it is a cheaper method of transparency that does not support varying levels of opacity. A pixel using $alphatest can only be displayed as 100% opaque or 100% transparent.
  
  
• Here's a list of important stuff I use in the Texture shift menu, and how each one works.
  

Displacements

To make "realistic" geometry in your map, like rolling hills, cave walls and ceilings, you can use Displacements. Displacements are faces that have been broken up into many triangles and can be sculpted or 'displaced'.

This is Waffle's tutorial on it, covers a lot of the complicated stuff in it but Phillip's tutorial is shorter and a bit faster to go through the basics of it.

https://www.youtube.com/watch?v=04cVm3bwM3s&ab_channel=TopHATTwaffle
https://www.youtube.com/watch?v=nre432l_OTc&ab_channel=3kliksphilip

I used Displacements in my map for the sides of the Red spawn, as well as the cave ceilings and walls.

Overlays + Decals

https://www.youtube.com/watch?v=9xQ-6tfhP0c&ab_channel=TopHATTwaffle

Overlays and Decals are textures you can stick on the side of flat geometry. Difference between each is that Decals can't be resized (only resizeable through VMT) and Overlays can be stretched and resized in hammer. Each one has it's good and bad perks.

An overlay doesn't take up any edicts, and can be used across multiple faces if needed. Check the Brush Faces keyvalue, then use the Pick tool to pick the faces the overlay will need to stretch across.

Other than that you won't have to mess around with the Overlay properties.

When making an overlay, try to keep the size to a square number. If your custom overlay is smaller/bigger than a square number, put it in a bigger canvas size and make the outsides Transparent. The other option is to use SprayMaker5000, which can take any size and put it through without stretching it. (see Making Animated Textures with smaller sizes)

Note that putting an overlay on a very large brush face can cause compile errors, so if they happen the solution is to break the brush into smaller pieces.

Trap Indicators

To make traps more fair to the players, Trap Indicators can be used to tell where the traps start and end.

The best way to indicate the bounds of a trap are to make it obvious to the player using detailing. This is more immersive and isn't repetetive. A good rule of thumb is to not have things that magically appear, because they can't be used to gauge trap bounds because they aren't visible until the trap is sprung. Instead, the components of a trap should be visible before the trap is sprung so players can work out where is dangerous or safe just by looking around.

The minimum requirement to make indicators is by using a flat line/hazard tape. You can use other lines textures for trap indicators, not just hazard tape. The best kind of tape to use is a square/rectangular tape texture, not the one with the jagged edges on it. The jagged one won't look good stretched across.


You'll need to toggle Texture Lock and Texture Scaling Lock to make a non-stretched line. Texture Lock locks it from repeating it's own texture when stretched or resized in hammer. By default it's on, so uncheck it to turn it off and stretch your line across a surface in front of your trap.


Some traps don't need them, since it's near obvious what looks like a trap. (a giant wooden breakable gate, a long ramp with a ball at the end, a pile of bombs on one flat texture different from the others, etc)

trigger_teleports

Teleports are triggers that will teleport a player to a different location specified by an info_player_teleport, or by another point entity. They can teleport players to any point entity that has angles and an origin. You could use info_target or logic_relay as an example. logic_relay is good because it does not use an edict.

These can be used to transition to different sections in your map, and also for Death to go from room to room. These are used a lot for the Minigame room, where you will need a few teleports for both teams and for each minigame you need to teleport to.


If you want a smoother transition from teleport to teleport, use the Local Destination Landmark keyvalue and specify your own teleport trigger. If a player walked into the teleport hugging a corner, it would teleport them to the info_player_teleport w/o LDL. If he did the same thing with an LDL trigger, he would spawn in at the info_player_teleport but a distance away from the teleport end depending on where they jumped into the teleport at.


If you wanted a teleport only one player could use (activated by button or some trigger by player) You could use an entity called point_teleport, and set what it teleports to !activator to teleport the guy that activates it. (see Special Output Commands for more)

trigger_catapults

Catapults are trigger brushes that throw someone in a direction at a chosen target entity.

You could use a info_target to be the target for the catapult to launch at, or you could use the Catapult's own origin as it's target, to save on edicts. Just drag it's origin across the plane and it will show in 3D view where it will be.


Something important to know about these is that you will need to adjust it's Player Speed to get the angle at how high/low you want to launch a player at.The higher you set it, the lower the throw will be, and the lower you set it the higher it will go. Experiment a bit with these to find the right throwing height for your catapult.


Make sure to combine a catapult or something like this with a Cancel fall damage trigger to stop players from losing health. (See Attributes Trigger)

Special Output Commands

Wiki: https://developer.valvesoftware.com/wiki/Targetname#Keywords
There are some special outputs you'll need to know to kill things like Template entities and specific players. These don't show up as official outputs in Hammer, but they work when used for their purposes.

!activator
This targets the entity that activates it, or the "activator". This is used for entities that need to target the player to change something about him, like changing his color or teleporting him somewhere. I also used it for killing the template entities that would hit the wall triggers where it needed to be killed at, since targeting the template entity wouldn't normally work.


!(templateentiy)&*
This is a command that targets all of the entities connected with one template entity. The * at the end of it is a "wildcard" that specifies any extra entity clones that were made from that template. It's used commonly with KillHierarchy to kill any entities that somehow didn't get killed by the kill trigger, and hung around for too long.

Minigames

When a player makes it to the end of a DR, there should be a good incentive and reward for beating one. Minigames are the main prize when a player beats the activator and makes it to the end of a DR.

Minigames can include Red team only, sometimes including the Activator for vs minigames. Some minigames have been done to death on other maps, and some minis are better/worse than others you can make. I will list the most to least common minigames I have seen done before to give you some starters to what you can do. I won't limit your creativity to what minigames you can make, they can be any kind of minigame you can think of.

• Insta-Lose/Insta-Stalemate
  DO NOT PUT ANY OF THESE IN YOUR DR. What it does is self explanatory, it calls the game as a win for Blue team (lose) or for no team (no win). These are L A Z Y minigame choices, they do not give players anything fun to do, It wastes people's limited rounds and it ruins the experience for the rest of the players when you beat a DR only for someone to just refuse to do a mini and pick one of these, to solely make everyone mad.
  
  
  
• Humiliation
  A little better than insta win, you get to humiliate the death with a funny skit/joke that results in the activator's death. Fun for the players to watch, sometimes you can kill the activator if it's intentional.
  
  
  
• 50/50 or Chance
  50/50 is also self explanatory. It decides by a 1/2 chance which team dies. This is a step up from Instawins, and can be fun since the activator's life is on the line, but can be kind of boring if there's nothing cool happening (ex: floor break 5050s). Just do it in moderation, don't make multiple 5050 doors to the point where it'll be unfair. (ex: 5050 Rush)
  
  
  
• Obby/Platforming/Gauntlet
  Most versions of this mini are a straight run through an obstacle course, dodging moving objects and sometimes combining advanced platforming techniques to make it to the end without getting caught by a motivator behind.
  
  
  Most implementations of this game cause a lot of players to jump over some tiny platforms with some ♥♥♥♥♥♥ results. I would advise to make this game wider so it can accommodate a lot of players, or start with wide platforms and graduate to narrow ones as people die. This will gradually let players build up their experience with the gaunlet much like making your deathrun.
  
  
• Arena/Fight
  A fight mini is when the last living players and the Death are set in one room/arena, and either team must kill the other to win. Make sure to have a good arena room with obstacles, and different areas to fight in (if you need reference you can look at some Versus Saxton Hale maps that function the same way). Make sure to also include a timer, either in the output settings or in the arena timer, so that way players can't stall.
  
  
  This can be unbalanced with some servers running Versus Saxton Hale based dr plugins, where the activator is turned into Hale, who has staggering amounts of health compared to the red team, which means it could be too easy for Melee Only servers, where one blue is overpowered by the rest of the team. There is a Prefab template to fix this problem, called Health Scaling. It scales up Death's health to a multiple of his own health times the amount of players alive, making it a fair fight. If it's used on a server with a VSH plugin, the health scaling switches off. You can get it here[cdn.discordapp.com] if you're interested.
  
  
• 9 Square
  9 Square is a luck based minigame. You pick a square to stand on, and pray that luck doesn't break/sink your square. It may seem a bit complicated to make at first, but it involves using logic_case to draw luck for platforms. It's done a bit to death for other maps but it's ok for a mini. It can also be amplified by upping the amount of squares you have to stand on, or even making another 9 square playfield for Death to play along in.
  
  
  The game has flaws, since as long as there is at least one red player per square, red are guaranteed to win. To fix this, you can only allow eight reds to play, and lock them in place once they choose a square so they can't change.
  
  What I did to fix this problem in my map is to have the winners of both minigames fight the death. Again, this could be unbalanced when I talked about the differences between Hale servers and Melee Only servers, so plan accordingly.
  
  
• Spinner
  Spinner minis are a good mini for Death to play in as well. A physbox combined with a hurt trigger sweeps around both sides in a circle attached to a func_motor. Kinda boring on it's own, but this can be amplified with alternating spinner pole positions, and other moving obstacles to make it better.
  
  
  Make sure the trigger_hurt can kill engineer buildings and the physbox is not solid so it can't be blocked (unless that's intentional).
  
  
• Color Games
  Color game is sometimes confused with 9 Square as they are both setup with the same structure. Usually 9 squares are placed, and the game will pick a random square, and show the players to move to that square before time runs out and the other squares collapse. This has been done a couple times before, but it's still fun to play. There have been iterations with less platforms, and even more logic based ones like Simon Says.
  
  
  
• Dodge
  Dodge is a pretty simple one, you have to watch and dodge moving obstacles to survive. This has been done a few times, and can be amplified with faster blocks and Death being able to play.
  
  
  
• Boss Fight
  A boss is a fictional character you battle somehow. Boss battles can contain obstacles but they can also involve doing damage to an NPC.
  Most boss fights have players standing on a big platform that will alter depending on what obstacle comes at you to dodge. This can be amplified by making more challenging obstacles to dodge and using logic/strategy to beat the boss. Some more skilled mappers have made NPC bosses that can target the player and you have to damage it to win.
  

You can always expand on these ideas and create your own minigames using the skills used here.

Respawning Dead

At the end of a deathrun, the players that died during the deathrun would like a chance to be brought back alive again, right? You can respawn players from a specific team with a game_forcerespawn.

In whichever entity you use to activate it, make sure to specify which team you want revived by putting 1 (Blue team) or 2 (Red team) in the parameters box.


In some games, this respawn is activated by touching a trigger when the player enters the minigames room, or can be activated by a Respawn Dead button. These are pretty easy to make compared to other options.


Throw all of that out the window, because having an automatic respawn with no risk or buildup involved is c r i n g e. It makes players not care too much if they die or not in a DR and get too relaxed since someone else will respawn them at the end. If you happened to attach it to a carried intel or a hard to get secret, then it would make things more interesting.

For example, I made an intel that when you cross the minigames room, it will respawn everyone who died. This is a great challenge since players will be able to pick up and drop the intel to others, and try to depend their lives on getting the intel to the end.

Secrets

Secrets are Misc bonuses that could be a special cosmetic the player could pickup, or a secret room only for those who look hard enough. They are rewarding side challenges usually not a part of the DR path but are enjoyable to find.

Here are some of the common ones I see:

• Shrink Potion
  This is an spell trigger that can turn the player small, like in the Carnival Of Carnage map. This can be used in other secrets as well due to the new size being able to fit in small holes.
  
  
  
• Sprite Trails
  Sprite Trails are created with env_spritetrail. They can be parented to a player to make them appear to have a blue line/sprite following them where they walk.
  
  
  
• Credits Room
  These are small rooms hidden in the map where the map creator makes textures that credit the people that helped him make the map. These don't have to have special things hidden in them, they can be a nice room to unlock and look in.
  
  
  
• Music Room/Music Secret
  Music Rooms are rooms seperate from the map unlockable by hitting different triggers to get to it. It has a selection of music you can choose from and play in the map during the game. Music Secrets can be triggers that play a randomly selected piece of music.
  
  
  Remember putting more music files in your map inflates the size of the file. I would advise against doing a music room for this reason, and for music used in your map, convert your music to 128kbps. It keeps the file size of the music file down and keeps the same music quality.
  
  
• Collectibles
  Collectibles are special items like sprites or models that can unlock bigger secrets when you collect them all.
  
  
  
• Unlockable Minigames
  Minigames that can be unlocked by hitting different triggers or by collectibles. These can be the better minigames out of the lineup of minigames available.
  

Secrets are not secret if people can discover them easily, or get to them easily. I advise against having a secret that's easy to trigger, because it's always the first player who gets there who will get the rewards, which makes it a race. Also consider having secrets only available on some rounds, using a logic_case and PickRandom.

Decompiling Maps for Reference (BSPsrc)

To look into another map and figure out what they did to make a minigame/secret/trap run, you will need to extract the VMF from the BSP file you downloaded it from. This can be done with BSPsrc. (See Mapping Programs)

BSPsrc is easy to use when you get the hang of it. First, open up the file where you put the BSPsrc version into. Run the BATCH file (Not the JAR file) and it will run a program through Java to start up the program. If you don't have Java installed already, download one to make this app run.


Next, click Add to add a map to the list of maps you want decompiled into a VMF. Go to Steam>Steamapps>Common>Team Fortress 2>tf>download>maps and you should find the list of maps you downloaded in BSP form.


Click on the maps you want to decompile and hit Open. Your chosen maps should now be in the list window.


Next, hit Decompile, go to the file folder you will put the maps in and hit Save. The program will open up a progress window and stop when it saved the map. Go to your decompiles file folder and the VMF will be in there to open up in Hammer.

Do's and Don'ts of Deathrun

This section talks about deathrun gameplay, and what you should and shouldn't do in a deathrun. Some of these are repeated from other sections in the guide which should be a summary for you. I had some other people contribute to this list, so any repeats of what I said are their parts that I think are pretty good to keep.

DO:

• Play on other maps for inspiration for what traps/sections/parkour/gameplay stuff you can add to your map
  
• Playtest your map/playtest the map with other players/in a playtesting group before shipping it to the public. They may have second opinions about your map that could be very beneficial.
  
• Design and build as if all weapons and abilities are available without restrictions. This ensures minimal exploits and even opens up potential for more interesting gameplay
  
• Make the activator partition wall at least 32 units thick to prevent the activator's weapon model from poking through the wall and minimising the chance their dynamic shadow will be cast through it
  
• Use a shadow controller to have dynamic shadows pointing straight down to avoid the above
  
• Learn how to use and build cubemaps
  
• Repack your map to make it smaller (repacking is different from packing)
  
• Make your assets as small as possible by trimming and compressing them. Use MP3 for sound and music, unless you must have it looping in which case use wav and the MS ADPCM codec at 4 bits.
  
• Spend some time on lighting and sound. They make the map more immersive
  
• Have a timer in every mini game in case players stall
  
• Put a control point in arenas to cause players to come to the centre and kill each other
  
• Have some form of motivator to stop players stalling. Don't delay it for too long or it doesn't serve its purpose

DON'T

• Don't Make 50/50 doors in your map.
  
• Don't Turn on Radius Culling in hammer (See Leaks)
  
• Don't Make traps oversized and impossible to outrun but also dont make traps extremely easy to outrun. Moderately size your traps.
  
• Don't Spam multiple unfair auto traps on your map (floor breaking ones)
  
• Don't Detail the map until you've play tested it and are happy with the traps and layout
  
• Don't Just play test the map on your own with bots. People can show you stuff you would miss
  
• Don't Respawn all players at the end for free, because it makes surviving worthless
  
• Don't Treat the activator as if they don't matter. Their experience is just as important as the runners
  
• Don't Build top-down activator corridors because they are a pain to use
  
• Don't Teleport the activator around unless it's absolutely necessary. You make them miss runners and it will confuse their sense of where they are
  
• Don't Use anything but Block Bullets on the activator's side of the partition wall. It provides the most clear view of the runners, cannot be sprayed and ensures damage can't get through
  
• Don't Have an AFK killer for the activator. It should be left to the server to decide how to deal with them
  
• Don't have a free run button. The death can call a freerun through chat, and a freerun button would be too much temptation for the death to call consecutive freeruns, which would ruin the game for everyone. This was a popular concept when first introduce but it actually does more harm than good. Free running should be a trust exercise between the teams - an unspoken contract. It heightens the tension if the runner knows the trap can still be triggered. Also, if the activator is bullied into pressing the button it's no fun for them. It also just reduces the number of free runs on average through dumb luck

I will take suggestions for more to add to this list.

Making Animated/Gif Textures

I made a guide covering my ways of making normal gif textures for VTFEdit, you can apply the same thing to Hammer and Texturing, just add in the VMT knowledge and my Proxy sheet for making the animated VMT textures and you'll be good to go.

https://steamcommunity.com/sharedfiles/filedetails/?id=2100647936

"LightmappedGeneric"
{
    "$basetexture" "kd/kd18-ani"
        "$translucent" 1
        "proxies"
        {
            "Animatedtexture"
                {
                "Animatedtexturevar" "$Basetexture"
                "Animatedtextureframenumvar" "$frame"
                "Animatedtextureframerate" "5"
                }
        }
}

Making Textures with smaller sizes (SprayMaker5000)

What if you wanted to recreate a Video Game level, and you needed sprites/textures that are smaller than square numbers? That is where SprayMaker500 comes into play!

First, get your texture that would be under the square limit. I'll use a Donkey Kong Arcade sprite I used, a Gurder rail that's 16 x 8 pixels. You don't have to use a sprite by the way, you can use other images doing the same things I'm doing, just don't use Pixel Art for them.


Drag it into the box, and you'll want to uncheck Auto-crop and check Pixel Art. Auto-Crop crops off sides of your art that we won't need for this, and Pixel Art enhances sprites like this. Set the format to either R8G8B8 or A8R8G8B8, either one works. This format will take things that are under the square limit.


Hit Save As, and go to your materials folder/wherever you're keeping the VTF files for your map and save. It will make a VTF file to that folder. Next, open up VTFEdit and open that vtf we just made.


Check off Clamp S and Clamp T on the side bar, use Auto Create VMT and hit save. In the VMT file, all you have to do is make it transparent. Remember to use "$alphatest" 1 since it does a better job here than Translucent can (see Texture Design)


In your map, pick the brush face you want to apply the texture to and apply. Naturally it won't fit the brush face perfectly. Remember to use Texture Scaling and Align to help you out here (See Texture Design)

You can also do the same things with Animated textures as well, just add the amount of frames you need in SprayMaker.

Making Props Intro

In some cases, you may need more than good geometry design to make your map look good, and sometimes you won't be able to find props for them online. The next best thing is to make your own props.

The first way to make your own props is through something called Propper. It's a custom FDG like the Attribute trigger that you can use to make your own props out of the geometry inside hammer. Note this isn't the most efficient way to do this, and Propper has some issues with making some complex designs.

The other way is to use an animation/modeling program like Blender. It's a tad complicated to get into Modeling, and the program has to work on systems with good graphics cards. Also, I think the versions past 2.90 have a weird bug where they won't launch at all, so 2.90 is your best bet if you want to use Blender.
https://www.youtube.com/watch?v=MF1qEhBSfq4&list=PLa1F2ddGya_-UvuAqHAksYnB0qL9yWDO6&index=1&ab_channel=Blender

Making Props in Hammer (Propper)

The first step is to get the Propper FGD from TF2maps. Follow the instructions to install the fgd and it should run in Hammer.

Download: https://tf2maps.net/downloads/propper-patch.9784/
Setup: https://tf2maps.net/threads/guide-getting-propper-working-nowdays.38589/
Wiki: https://developer.valvesoftware.com/wiki/Propper

After setup, select all of the geometry blocks you want as a part of your model, and make it a propper_model in properties.


After this, follow Matty's instructions on where to send your model in your map model files folder.

Publicado originalmente por worMatty:

For anyone using Propper, I recommend you use the following entity values:

Name: <whatever>
This is the Propper entity's targetname and only needs to be filled in if you are using the model's brushwork as its collision mesh. If you're using another brush for the collision mesh or are making a non-solid model you don't need to give the entity a name.

Model name: my_project/my_prop1
Appending a number and sometimes the dimensions of a model can help you tell them apart if you ever need to create more than one version.
You should give your model a project directory so it doesn't just go in the root models folder. It will keep them organised and separate from other assets, and greatly reduce the chance of models downloadeded from servers overriding your map's models, especially if you use a unique project name. You can add more directories after the project name if you need to keep models separate inside the project folder. A good example of a project name is the map's name abbreviated, e.g. 'dr_swe'. All compiled models will go in tf/models.

Material path: models/my_project/my_prop1
This is the same as the model path with a 'models' directory prepended to it. The convention is to keep a model's materials in a directory structure that matches the one used in the model folder, and all within the 'models' folder inside tf/materials. Using folder names and a structure that is different to the one used by the model files could cause confusion.
I recommend you store each Propper model's materials in its own folder. If you don't, your Propper models will share VMTs, so any changes made in one will happen in all of your models that use it.

Try not to store your assets in root directories. When Propper creates the files it dumps them in tf/models and tf/materials so you will need to move them to your custom dir yourself. You need to restart Hammer to see the new models.

Once you have that set up, go to Run Map, check off all of the normal compile options and go to Expert options.



Check off all of the default options, and fin Propper's options through the drop down menu. Set up your parameters like I have them, and hit Go!


This will run a small program to create the model files, and after it completes, restart hammer and try finding your model in the model browser. If your model has small imperfections, try remaking the prop again to make it work. Like I said, Propper isn't that good but it gets the modeling job done. See the wiki and the setup guide for troubleshooting in Propper.

Downloading/Moving models to your hammer directory

In some cases, you won't have to make your own models for your map, since there are plenty of good models on TF2maps to use. TF2maps has content for many kinds of models they made themselves or used from other maps, as well as super content packs of many textures, models, overlays, and other parts. Downloading each part is a bit complex, but it's not hard.

To download a Content Pack, just use the .exe that came with the download, and follow the Installation Wizard instructions to install your content.

(the list of content packs as of Febuary 2021)

To download a piece of content manually, put the folder in the tf/custom folder. Sometimes they include a .txt file to instruct you on where to put it.

There are 2 places you can put custom content, either in tf/custom or in the tf folder itself and merge the folders together. I would suggest putting them into your tf/custom folder since you can better keep track of where your download files are and can delete them easy if needed.

Making Sprites

By Request, Sprites!

Sprites are one-sided images that are always pointed towards you in the map. Most likely you know these from light effects like a "bright spot" looking at some lanterns or from looking at sprite sheets for retro or 8-bit styled games.

Making one of these is a bit more tricky than your average brush texture, but it's not hard when you get the hang of it. For starters you may need Spraymaker 5000 to make 8-bit style sprites since it can make vtf files from images that are under the square number limit VTFEdit is under.

For a single frame, non-bit sprite, you can skip the steps needing SprayMaker for it, it's not needed. Make a vtf for it in VTFEdit, and put this into the vmt for it:

"Sprite"
{
	"$basetexture" "(Your Folderpath Here)"
	"$alphatest" 1
    	"$spriteorigin" ".50"
}

"Sprite" helps define the material as a sprite, so it will work with lighting on an env_sprite entity only.
"$spriteorigin" ".50" keeps the sprite centered at the env_sprite's origin, so the entity doesn't attach/hinge to a corner of the material being used.

For animated sprites, you can use this for your vmt:

"Sprite"
{
	"$basetexture" "(Your Folderpath Here)"
	"$alphatest" 1
    	"$spriteorigin" ".50"
	"$translucent" 1
        "proxies"
        {
            "Animatedtexture"
                {
                "Animatedtexturevar" "$Basetexture"
                "Animatedtextureframenumvar" "$frame"
                "Animatedtextureframerate" "10"
                }
        }

The extra proxies for Animatedtexture makes the sprite flip through it's compiled textures in the one material during the game.
You can adjust how fast the animation goes by adjusting the Framerate value here as well.

For 8-bit style textures the setup for the VMT's is the same, but making it is different.
Just drag your 8-bit style texture into Spraymaker's box, check off Autocrop and turn on "Pixel Art" check boxes. Then go to Save As, find your folderpath where you're keeping your sprites at, and save to it. Open up VTFEdit again, open up the vtf file you made, and save with Auto Create vmt on in settings. From there, just edit the vmt's settings as you please.

For the animated 8-bit style sprites, in Spraymaker click the Frames arrow to however many frames your sprite has, and drag/drop your sprite frames into the boxes. What is very important is that you keep the frame size between every sprite you put in the same, or else it will stretch the texture down to the regular size, making it ugly. To fix that, you'd need to open all of the sprite frames in Paint.net, and take the max width/height of all the frames. Then, expand the Canvas Size out to the max width/height of all of your other frames.

Detailing

Nodraw Article: https://nodraw.net/2010/08/tf2-density-of-detailing/

Details are overlays, geometry, and decorations that build the atmosphere and ascetic in your map.

Publicado originalmente por Velie and Me talking about detailing:

it makes the environment less boring and more alive. If done correctly it can be good.
if you remove every props and brushes just done for details in HL2, would you still like the game?
Not really, cause details are a part of the environment, and what really makes and creates the atmosphere from being boring.
Place detail where you want players to look
Do not feel required to make every surface a point of interest
Detail, if used properly, can bring story to a map
Only use textures to fake effects far enough away from the player

Keep detailing to details that go with your map's theme. If the theme you use doesn't need too many details, you don't have to overload your map with them. Try to do details in moderation, so they don't distract from the gameplay.

A good example of map detailing can be found in maps like Paradoxal and Blackmesa.

In Paradoxal, attention to things like stylistic posters made with photoshop, special models, and the labratory sections skewed with many types of texture work makes for good detailing. It helps bring more environment to the map and gives artistic depth.


Blackmesa uses a lot of materials/models from TF2, but uses them in creative ways. Using models from HL2, and combining that with layouts and geometry reminiscent of Half Life, it makes the atmosphere come alive.

Dealing with Leaks

https://www.youtube.com/watch?v=5X2mrlmp9Pc&ab_channel=TopHATTwaffle

Let's say you tried to compile your map, but it won't compile/creates a glitch effect on textures like Water. Why is that? It's because you have something called a Leak in your map.

A leak is when you leave a crack of space open in your map, meaning the outside void can touch the inside of your map. This happens if you don't seal up all of the cracks, or if you're using Radius Culling.

My first step when I get a leak error is checking if I accidentally pressed in the red circle with the R in it at the toolbar. It Creates a sphere around your location in hammer that will only show what parts of your map are inside your circle. Good for narrowing down your vision on large maps, but it also affects compiling, since it will also cut out everything outside that circle when compiled.


The step after that is the one covered in a lot of video tutorials: Finding the leak. To find the leaks, compile with BSP-only settings in Run Map, and go to Map>Load Pointfile to load the leak line. The leak line will target an entity that has a connection to the outside void, drawing a 3d line from it to the outside through the crack in your map. Usually you can fix these by raising a block so it covers the leak, but if the pointfile is pointing to a place with no leaks, then it's either radius culling or another problem.

Compiling your map through Compilepal will bring up hyperlinks with each error it finds. They will show a troubleshooting page for each problem/error you find in your map.

Visleaves and func_detail

Visleaf Wiki: https://developer.valvesoftware.com/wiki/Visleaf

The first step to optimising visibility is to design the map to limit what is drawn to the player. Find a decent guide like this: https://nodraw.net/2009/12/optimization-in-source-a-practical-demonstration/

When you compile your map, you may get errors relating to too many visleaves touching one place. Sometimes your map won't load at all because of something like this.

These visleaves are compiled into the VVIS phase of compiling your map. VVIS is often the longest process in the compile and what causes a long VVIS time depending on how much stuff you have in your map. Do not worry if it takes a long time to load this part! It is perfectly fine to have a long load time as long as you don't have any prop/leak errors in your map (see Leaks)

Visleaves are "hollow volumes in a map which defines a 'cluster' of visible surfaces." They are outlined shapes that show what a player is supposed to see if he stood in a visleaf. If there are too many visleaves, the map won't be able to load up or there will be visual problems. The way to get rid of this is by using func_details.

Func_details work the same as a normal geometry block, except they can't be used to seal the map since they are entities, and they don't use edicts up. When hammer compiles the map, the VBSP ignores these func_details and draws the visleaf line through it. It also means less visclusters.

Turn things like complicated geometry (Spikes, cylinders, cut surfaces, and geometry that sticks out or causes a lot of visleaves) into func_details.


Note that you don't need to make every brush in your map a func_detail, just make sure that complex shapes like spheres or spikes get turned into func_detail

Keeping Edicts down to a stable level

To make your map run at a comfortable level, and for it to not crash, the amount of entities used should never exceed 2048 entities. In mapping, we call entities edicts for short.

Edict number has no bearing on framerate. Edicts are just entities that have their properties communicated by the game to the client. For example, a player is an edict because clients need to know the player's position.

Note that not every entity is an edict. There are two categories of entity: Server-side and networked. Most logic entities like logic_relay and logic_timer are server-side because clients don't need to know about them. The game server can support up to 2048 server-side entities and up to 2048 networked entities/edicts simultaneously, making a total of 4096. Unfortunately you can't change one type to the other. Most of the time, mappers don't need to worry about server-side entities, but it's more common to approach the edict limit.

In DR mapping, usually 1600-1700 is the top limit that should never be exceeded. Since your map will be played by people with cosmetics (Players/Cosmetics count as edicts) they will add to the limit, along with some plugins the servers have on them.

In TF2 you can check how many edicts are running at a time by entering sv_dump_edicts into the console. This will bring up all of the entities in use and the total amount in a number at the bottom. Remember this command can only be used with cheats on, which means you'll probably only be able to use this on your own playtests of your map.

This means you must keep in mind to budget out what features/minigames/special effects and stuff you want for your map to stay under the limit.

Clean up any edicts you won't use after the motivator passes an area. Kill any edicts you won't use again after activating a trap, or after the motivator crosses a section, since no players will be in that section.

Every edict that is going to exist in the map is respawned when the round restarts, so when you combine that figure with all cosmetics players are wearing when they spawn, your highest number of edicts in use is going to be at round restart. The number of edicts will only go down over time as players die and their cosmetics are killed.
You only need to free up edicts if you intend to create more later. For example, using point_template to spawn multiple sets of the same edicts. I wouldn't spend any time on cleaning up old edicts unless it's actually necessary.

If you have multiple triggers that do the same thing (trigger hurt maybe), link them together as one.

Static props don't count as an entity. When the map is compiled they become part of the geometry. Dynamic props do use an edict. On any dynamic props you're using, disable Bone Followers since they it's used for ragdolls and rare situations only, and not necessary to make the prop work

For using things like env_lasers, you don't have to use an info_target for their endpoint. You can use any point entity (must be an edict) as the target. Best use would be to use a logic_relay you're using for something else as the endpoint. func_door can be useful for that, and the origin will act as the target. If the mapper requires a precise target, they can parent an env_spark and use that as the target. info_target can't be parented, as it'll despawn due to a weird coded behaviour.

You can even use logic_relays as replacements for info_player_teleports, since teleports can take any point entity as the teleport point, and use an Angles keyvalue to tell which direction they would face when they exit.

Compiling Maps (CompilePal)

The best way to compile your map is to use CompilePal, a compiling tool that you can adjust different compile settings on.The main benefit of CompilePal is its ease of use for new mappers and its auto packer. You can use Hammer's compile tool, but it isn't as accessible as Compilepal is when it comes to individual compile settings.

When you compile for a small playtest for yourself, or to check if something works, compile with Fast to skip complex lighting. This may create weird lighting, and Cubemaps aren't compiled here so they won't work.


When you want an Official Release compile/Playtest compile, use Full or Make your own Preset compile with Static Lighting (See Lighting Compile Options.) A full compile should include VBSP, VVIS, VRAD, COPY, CUBEMAPS, PACK and REPACK, and GAME to launch the fully compiled bsp in TF2. The best way to make your own is to clone the original presets and edit the clones you make to your liking.


Perform as many changes in Hammer as possible before compiling. Then compile once, and test as much as you can of the map before making any changes. Don't get into the habit of making a small change and recompiling repeatedly, because it wastes time. Keep notes.

Development Console Commands

Some helpful development commands you'll need for Console to make your map:

• sv_cheats 1
  This turns on cheats, which you'll need to test your map
  
• noclip
  You can fly with this, doesn't really need an introduction
  
• bot
  Spawns a bot on your server. Is needed to start a DR round.
  
• sv_dump_edicts
  This will bring up all of the entities in use and the total amount in a number at the bottom.
  
• cl_drawhud 0
  Gets rid of the huds in your view. Useful for taking map screenshots for the Gamebanana page.
  
• r_drawviewmodel 0
  Useful for getting rid of the playermodel you see when you attack. Useful for taking map screenshots for the Gamebanana page.
  
• ent_fire
  Using this followed by the entity you want to test starts up/activates the entity. Good for testing specific parts.

Lighting Compile Options

For some static props, their shadows may seem really blocky and unrealistic. Also in some flat metal models, they will go dark no matter what lighting you do with it. With special compile options, you can make them more realistic and look less bad. Matty made a good guide that discusses lighting compile that's pretty good.
https://steamcommunity.com/sharedfiles/filedetails/?id=2382204622
I would suggest making your own compile preset in Compilepal with these lighting options, you'll need them for every map.

https://nodraw.net/2010/12/lighting-compile-options/
This page in Nodraw also covers the same topic for extra help.

Good Playtesting Habits

it's a bad idea to publish without thoroughly play testing, and that the mapper should take time to address all problems raised in a play test. Never rush into publishing a map even though it is exciting.

As said before, Don't Just play test the map on your own with bots. People can show you stuff you would miss by yourself.

Ask people from other communities like Playtesting groups to test your map before publishing. Having second opinions can give you more ideas for your map and also well needed criticism to improve it.

Staying On Time

When you get a playtest organized with someone, make sure to arrive on time. Don't rely on if someone recorded what they said because that may not be the case all the time with playtesting servers.

Open Mind and Thick Skin

It is very important to keep an open mind when taking criticism from other players about your map. Players and Playtesters may find problems with your map and suggest improvements that you may not personally like. Having Thick Skin (Being able to take criticism without getting mad or stubborn) and an open mind can help you build yourself as well as listen better and make better improvements that you may not see from your perspective.

Posting Your Finished DR Map

Now that you have your final BSP of your finished DR map, it's time to post it to Steam and Gamebanana.

Posting to Steam Workshop

It's a bit harder to update your map from here, but it's useful to have your map up here so you can rack up free steam points for submitting.

In TF2, go to the Wrench icon in the lower toolbar, for the Workshop. You should come to a screen like this:



Click Maps, select your BSP, select the preview image for your map (has to be 512x512 for all submission preview pictures) select your other preview pictures of your map, write in your title and description (you can copy it from your GB page) and hit Submit. It should submit your map to the Steam Workshop.

Posting to GameBanana

Gamebanana is the best place for putting updated versions of your map since Admins/people that can add maps to their servers browse here a lot among other file sharing sites.

Go to the Add Mod button, and follow the menus to get a TF2 Map submission going. Complete all of the requirements needed to publish, give a short description of what your dr map is, and Submit.

Mapping Links

I'll give you the essential links for mapping for hammer. You may want to bookmark these pages if they come in handy later.

• https://developer.valvesoftware.com/wiki/Main_Page
  This is the Valve Developer Wiki. You can search up and learn entities, lighting, and other things that show up in hammer that you'll need.
  
  
• https://gamebanana.com/
  This is Gamebanana, a mod hosting and discussion site for making mods in different games. You will want to make a GB account to post your maps to so server hosts will notice it and use it in their servers.
  
  
• https://developer.valvesoftware.com/wiki/Team_Fortress_2_Sky_List
  In the Valve Dev wiki, you will need this skybox list so you can enter in the numbers needed for environment lighting around your map according to your chosen skybox texture
  
  
• https://www.youtube.com/playlist?list=PL-454Fe3dQH1L38FnKkz_O1CqYx6sKaXk
  This is TopHattWaffle's Mapping Tutorial Playlist. The reason why I'm not requiring it in the introduction is because he covers a lot of topics that you'll only need a few of, and UEAKCrash's tutorial is a bit faster. His tutorials cover specific topics that you may need extra help in.
  https://www.youtube.com/watch?v=jF3er5lsaeg&list=PL-454Fe3dQH1L38FnKkz_O1CqYx6sKaXk&index=1&ab_channel=TopHATTwaffle
  
  
• https://tf2maps.net
  This is a site for hosting maps, models, discussions, and mapping contests for TF2 maps. They also hold playtests, but they aren't as good as others are. You'll need this to search up models/props to put into your map.
  
  
• Death Ventures Steam Group: https://steamcommunity.com/groups/R60D
  Death Ventures is a discussion and playtesting server that does TF2 Deathrun. I highly suggest this place for playtests and help on mapping.
  
  
• https://developer.valvesoftware.com/wiki/TF2/Team_Fortress_2_Mapper%27s_Reference
  This is a reference of each TF2 class's info, including speed and jump height which you'll need to know when you make obstacles.
  
  
• https://nodraw.net/2010/12/lighting-compile-options/
  Nodraw.net is a discussion forum around mapping in general. The link talks about lighting compile options, which you won't need right now, but you will when you start compiling your map.
  
  
• https://www.interlopers.net/errors/?page=errors&params=
  This site has a compile error checker, which you will need to check for errors in the compiling of your map.

Conclusion

Well Done on completing your first map, future mapper! The maps you make will be enjoyed by the DR community for years to come! You can even use your mapping skills learned here in making other maps, your potential is only limited by how much you push yourself to make a good map. Thanks for reading, and have fun making maps!

I will take any suggestions for things I should add to the guide to help with mapping.

Credits/Special Thanks

worMatty: Guides, FGDs, a good chunk of the guide's info using content from him.
Velie: Detailing talking points.
Spookmint, Billy, Floor, BadToad, worMatty: Do's and Don'ts talking points.
Coronarena, Berke: Optimization advice
Cream Tea, ToppHattWaffle, others: Youtube Tutorials

Coming Soon

A guide focusing on func_tracktrain and path_track functions
A guide focusing on Textures and Texture Properties

[Lichowsky]

This deserves way more views, the most detailed explanation of how's and why's, no guide comes close to this one regarding dr mapping. All around awesome!

[Jackson]

You should definitely make a section about motivation to make a Dr map :troll:

[arctic dino]

As for teleporting players, you can also use AddOutput with the target being !activator as shown in this screenshot and not have to use a trigger_teleport at all: https://imgur.com/a/Rd6IKup

[Verdessence]

cool and sexy tutorial, you should probably add "tf_arena_use_queue 0" to the development console commands because the command allows you to choose any team you want if the gamemode is arena

look mom im in the credits

[courier]

text wall

[saucey]

you know valve hates tf2 right? your creative energy could go to much better use, like uhh

[a]

will u be my gf

[Cerrin]

Very good guide. Lots of useful information, tips, and talks about a lot of aspects on what makes a deathrun map not only work but also come out very good. I appreciate this guide a lot since I've been thinking of getting into mapping and making a DR map for a server I play on to add to its rotation and hope the players enjoy it, but I didn't know how to exactly start working on a map for this kind of gamemode. Also wouldn't have to bug my friend creamtea as much for any help since I now have this guide to refer to. Thank you very much for your hard work on making this guide.

[Bunz]

thats a lotta EFFORT