The Absolute Beginner's Guide to Quake 2 Editing

By Richard Neff

In the Beginning...

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.

Knowing the Components of the Quake 2 Engine

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

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.

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.

Brushes

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.

.MAP Files

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.

And Just What the Heck is a Leak?

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.

The Next Steps

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.)

A Room

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.

And that's about all the basics!

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.

Some Tips for Beginners

Go slowly. Don't try to make the perfect
level on your first few attempts! Make small practice
levels to learn basic concepts and effects before
implementing them in a level you care about.

Read a lot!
Read through all of the tutorials here at Rust
before you go head-first into map building. In fact, you
may want to fire up the ol' printer and get some of this
stuff in hardcopy so you have it in front of you while
editing. Trust me, you'll save yourself a lot of time and
frustration later on if you do this.

Learn your editor! One of the best
things you can do is visit sites dedicated to your editor
and learn what it can/can't do. It always amazes me the
number of people who complain, "My editor can't do
this!" when, in fact, it can. They just didn't take
the time to read all the tutorials out there.

Start small! Don't try to do every
single cool effect you've ever seen. A lot of this stuff
was done by people who had done a lot more maps than you
have, so don't assume that you can do the cool stuff that
Id or anyone else did right away. The truth of the matter
is that your first few maps probably aren't even
"playable" maps, so don't even post them - in
fact, expect this and realize that they are learning
experiences, not "playable" levels.

Keep rooms small too! The Quake engine
is very picky about size. The larger the room, the more
the Quake engine has to do to display the room and all
the stuff in it. Don't do large outdoor
areas!!! Until you learn what the Quake 2 engine can
handle, don't even try to create outdoor rooms. This is
better left for when you've gotten some basic
experimenting out of the way.

Plan ahead. Without question, the
biggest mistake of the beginner. Quake is very sensitive
to the number of brushes and entities in a single view.
The more stuff the engine has to render, the slower the
gameplay. Also, knowing what you want to do makes it
easier to create a level that "flows" well from
one room to another. Keep in mind a level isn't just a
bunch of different rooms connected to each other. It's
something that is designed to either complete an
objective in Single Player mode or to create a fair, yet
interesting battleground for DM mode. You have to plan
ahead to keep from spending hours on a map that doesn't
even play well or doesn't look good.

Ask questions, but don't bug people.
Most editors are willing to help a beginner out, but
don't abuse that willingness. When you have a question,
post it on a discussion board, like the one here at Rust,
or a public discussion area, such as a newsgroup. And
don't assume the world revolves around you. You're
question may sit a while before it's answered (and if it
goes unanswered too long either your idea can't be done
or you haven't exhausted the sources of information out
there.) Be sure that you've read FAQs and tutorials about
Quake 2 editing and your editor specifically before
posting questions - otherwise, you may get the short
reply of, "Check the FAQ" or some other
less-than-happy reply. Additionally, don't assume that an
author of a tutorial, FAQ, or reply wants a personal
e-mail. (Especially in my case!) You should ask before
you send questions whizzing through cyberspace using
e-mail, or you may not like the reply (plus still not get
your question answered by someone who could normally
help.)

Finally, have fun! Editing is a long and
tedious process, but the final result almost always makes
it worthwhile!