So, you've finally played Quake 2 until your eyes are bloodshot and rather than get some sleep, you've decided, "Hey, it would be sooooo cool to create my own levels!" Unfortunately, you're getting into level design rather late, since Quake 2 is really an evolution of Id games since Wolfenstein 3D. So, keep one thing in the back of your mind: it is not a trivial thing to do Quake 2 editing. It is a very long and time consuming process - but, rest assured, the first time you blast a Strogg in a level you've created yourself, you'll be very glad you put the time into it.
Just be aware that not only are you going to have to spend time creating the level, but you'll have to spend time learning the basic concepts, learning the editor you've chosen, planning the design of your level, waiting a lot on the compilers to do their job, and putting in the time to do all the picky little detail work on your level before it's "good enough" to post. Be fully aware that all of this takes some serious time, so don't expect to have a quality level in a few days.
The First Steps
The first thing you need (other than the registered version of Quake 2) is a level editor. Right now, I'm only talking about an editor that creates Quake 2 levels, not skins, texture, entities, models, etc. Some editors also include a few of those functions, but right now, let's just concentrate on the basic level editing functions. The first questions that are probably popping into your head are: "What's the best editor?" or "What did Id use? That must be the best editor!" First and foremost, you have to understand that there is no best editor!
I know, all your friends babble endlessly how great one editor is and how another sucks. But, the bottom line is that you are the one that gets to spend hours bleary-eyed in front of this thing, so you need to check out all the editors you can before committing to a single one. In fact, you may have already jumped the gun and bought/downloaded an editor. That's ok too, just realize that although it may be the editor you learn on, it may not be the editor that you use to do all your later maps. (And Id used a rather hard-to-get working QE4, which had an interface that was designed more for people who REALLY knew the game rather than beginners. If you're really interested in trying to use QE4 under Windows 95, you're probably much better off just downloading QERadiant - trust me on this.)
Where Do I Get a Level Editor?
Fortunately, you're in luck. Go to the Links page here at Rust and you'll see a listing of some of the major Quake 2 editors. Keep in mind that some of them are freeware, some are shareware, and finally some are retail products. However, don't assume that the retail products are any better/worse than the others. Also, each has it share of advantages, disadvantage and flaws. Most also have Web sites dedicated to updates, tutorials and other editor specific information (as opposed to Rust which is pretty editor non-specific.)
Additionally, there is something you may need beyond the level editor itself: the compiling tools. Id uses 3 compilers to turn the maps that editors create into fully playable levels for Quake 2. They are QBSP3, QVIS3, and QRAD3. Each of these has a different purpose which will be described later in this document. Some editors provide these files with the package/download, while others require you to download them yourself.
The key components of the Quake 2 engine are: Entities, Attributes, Brushes, .map files, and the compiler programs. Let's look at each and what it does.
Entities are the "active" objects of Quake 2. Things like monsters, weapons, powerups, triggers, etc. are all entities. Each entity in Quake 2 has a specific task that is hard coded, either in the regular Quake 2 engine or as a separate add-on modification, such as Capture the Flag (CTF) or the Mission Pack. Additionally, there are two different types of entities: point entities and solid entities.
A point entity is an entity that has a model preassigned to it. For example, a monster. The monster does not require the user to create the physical representation of the monster or its movement. This has already been done by the entity creator. When you place a monster entity in your editor, Quake 2 automatically puts the monster in its proper place. Typically, this also means that if you use a box and make it a monster, you don't need to worry about the size of the box, since it will be replaced by the appropriate model when Quake 2 runs. Some examples of point entities: monsters, lights, health, player starts and powerups.
A solid entity is an entity where the level designer does have to give a solid geometry in order for the entity to work. An example of this is a door. You have to make a door the size and shape you want. The advantage of having to define the solid for the entity is to allow a greater design range for which to create those entities. For example, you may want a double door rather than a single door, so being able to define this gives you that option. Examples of solid entities are: doors, triggers, buttons, trains, and platforms.
A common thing about all entities is that certain things need to be defined for each entity in the level to modify the behavior of that entity. For example a trigger isn't much good if you can't tell what is to be done by that trigger. So, each entity has properties that can be defined by the user. These properties are known as attributes.
An attribute is basically, the stuff that defines how an entity is supposed to work. For example, a trigger needs to have something to target when the player goes over it. So, one attribute of a trigger is the Target attribute, which points to the name of whatever is supposed to happen when the player runs over it. If the trigger is to open a door, then the Target attribute will have the name of that door. Additionally, a trigger entity also has a delay, which allows you to set the amount of time has to pass before the trigger becomes "active" again.
Now that we know what entities are, we can adequately describe what brushes are. Brushes are simply anything in the Quake 2 level other than entities. Basically, this means the walls, floor, ceiling and anything else that the player can't pass through, but don't really do any other functions. A good way to think of brushes is to equate them to bricks or building blocks. They simply define the structure of a level.
Some things to note about brushes, however. A brush can only be convex. This means that no "dents" are in the brush. You can't pass a straight line through a brush where it passes out of the brush and back in. For example, a square is a convex brush. A "C" shape, is not a convex brush. However, you can make multiple brushes to comprise a "C" shape.
Additionally, brushes must be solid and are comprised of straight edges. You can't ever be "inside" a brush (rooms are actually "hollowed out" brushes where you have six solid brushes making up the walls, roof, and floor.) The Quake 2 engine also doesn't support curved edges - however, you can have many straight edges on a "side" that make it seem curved. This was done by Id and other levels to simulate rounded objects.
This is the standard for all Quake 2 editing files. However, as with any type of "standard" in the industry, each editor may implement .map files differently - which may make it harder to open a .map file created in one editor into another. That aside however, all editors (whether they are able to import .map files are not) must be able to create a .map file so the compilers can create a playable level.
The structure of the .map file is actually pretty straightforward. It is a text file (meaning you can open it and modify it directly in any text editor, such as Notepad) that holds descriptions and attributes of the brushes and the entities that make up the level.
The Compiler Programs
As I mentioned earlier, you need 3 compiler programs in order to create playable Quake 2 levels. These compilers turn the text-based .map file into a compiled .bsp file which users can play. The first compiler, QBSP3, creates the initial .bsp file. This breaks up all the brushes into smaller brushes and builds the playable .bsp file. In fact, you could just run the QBSP3 compiler and have a playable map (and you'll usually do this as your maps get bigger for testing purposes.) However, the other two compilers do more modifications to the .bsp file that make it run faster and look better.
The next compiler, the QVIS3 program, does something known as visibility calculating. Basically, it calculates what a player can see from any given viewpoint in the level. The primary function of the VIS compiler is to speed the level up during gameplay be pre-determining whether or not a player can see certain areas of the map at the current viewpoint. While you may not notice much of a difference in the actual appearance of a VIS compiled map, the speed should almost always be faster than a map that hasn't had the VIS compile run.
The final compiler, QRAD3, is the lighting (radiosity) generator. Until this compiler is run, the map will not have any lighting effects defined. This means that the level will run completely lit, regardless of the location of any light entities or surface texture lighting. This is the last compiler to run, meaning you must run the QBSP3 and the QVIS3 compilers before this compiler can be run.
A thing to note about the compiled .bsp files. In Quake 1 textures used in the level were kept inside the .bsp file. In Quake 2 however, they are not. So, if you decide to use custom textures other than the ones originally used in the Id game, you have to provide those textures either in a .zip file or .pak file (which Id used to store all the .bsp level files) to distribute those textures. However, this is a little outside the range of what you should worry about as a beginner.
The dreaded leak - the biggest stumbling block to the beginner editor (and it even plagues more advanced editors from time to time). To understand leaks you need to understand how the Quake 2 engine views the world around it. By default, anything a that isn't in a self contained room, is in the 'void.' (not to be confused with the sky) Players can NEVER see or go into the void.
The best way to handle this is to realize that your level much be completely contained. Imagine filling up your level completely with liquid...if any of the liquid could escape, then your level is not completely contained - and a leak occurs. However, this checking occurs from the player start position and works out - so, if you have the player starting outside the outer walls of your level, a leak could occur as well.
Additionally, the player can't be able to see into the void. So, you can't use transparent textures as outer walls. This will also cause a leak error to be displayed.
As I mentioned, don't confuse this with the sky. A sky is simply a special texture property. The Quake 2 engine gives the illusion that there is more out there beyond the limits of your map, but from a design standpoint, your level still has to be self contained and the player can't see the void anywhere.
Keep in mind leaks can be very small...the slightest gap between two outer walls can cause leaks (and on a more advanced note - be sure to use the right compiler for your editor since some editors, such as Qoole, use 'floating point' sizes, while some compilers round off.) And some editors can use what's known as pointfile information to draw a line to leaks, while other editors don't offer this feature.
But, why worry about leaks? First and foremost, leaks are bad because they slow the engine down a lot. Also, they prevent you from running the VIS and RAD compilers, so you don't get proper lighting or a fast playing level. Both of which are considered bad and prevent you from having your levels posted or played by others. Finally, anywhere a player can see into the void may cause effect like the "Hall of Mirrors" effect where the last image is constantly displayed or a "grey area" effect, where the player is able to see grey where the void is.
Ok, so you've learned the basic concepts of Quake 2 editing, now lets look at what all Quake 2 levels need:
The Worldspawn Entity
The Worldspawn entity is a special entity that defines certain things about the map, like the CD track to play, the sky to use, the next level, and other things that affect the entire level. Keep in mind that with some editors, this may be listed or access differently (Qoole and DMM2 come to mind - Qoole requires you to bring up the entity window while no other entities are selected and DMM2 uses File, Game Options to edit these settings.)
This is pretty obvious. But, you do need to have a least a room before you can place entities into your quake level.
The Player_Start Entity
Even in DM and CTF maps, you probably want to put this entity down to test your levels. Some editors will even put this entity in if you don't explicitly specify it. You can have only one player_start entity. However, you need to have a player start, even if you use the DM or CTF starts, in order to play your map.
The player_start has to be inside the level otherwise a leak will occur. This is especially important with editors that put a player_start where the observer in the editor is when you don't have an explicit player_start entity defined.
That's is the overview of Quake 2 editing in general. Obviously, we didn't cover every single aspect of editing. Heck, we didn't even talk about how to create a room! That's because most anything else you want to do is going to be specific to a particular editor. Some editors will create a room automatically with all six sides, while some editors will require you to create a box, then "hollow" it out. Check out the tutorials for your editor on either the editor's home page or pages dedicated to that editor to help you get started.
However, Rust lists all the Quake 2 entities and attributes for the entities included with the Id game (however, not all modifications, total conversions (TCs), and mission pack entities are listed). Additionally, other tutorials are here for helping you to create better Quake 2 levels.