Submitted by
Gard on Sat, 2003-11-08 02:45.
Quake 2
The Absolute Beginner's Guide to Quake 2 Editing - 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.
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.
What about 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!
|
Texture Blending
Entity Properties