Revision as of 23:13, 25 March 2013

THIS IS VERY MUCH A WORK IN PROGRESS --Scampie (talk) 16:04, 25 March 2013 (UTC)

This article is meant as a basic introduction to how a Quake level is constructed. This tutorial will use the modern Quake editing software Trenchbroom in it's examples, but everything covered will apply to all editors for Quake. The goal is to teach a new level designer what goes into making a map, the terms used, what compiling is, and how to compile and play a created map. If you have ever created levels for the other Quake games, or for the Half-life/Source engine games, all of this will be familiar.

What's a map!?

A Quake level is created in level editing software specifically designed for the task. There are several editors available, and all of them create .map files. These .map files are used by Quake compilers to generate the final .bsp file levels that can be loaded by the Quake engine. Think of the .map file as a blueprint, and it contains instructions of how to make all the solid geometry of a level, and where all the lights and monsters and pickups should go. There are 2 major objects used to make these instructions: Brushes and Entities.

Brush: Your basic building block!

A brush

Our basic building block for constructing a level is the brush. All of our level's solid geometry will be constructed from brushes. But what do we mean by 'brushes'? The semi-technical definition in Quake level creation is that they are convexpolyhedrons. The less technical definition is that they are 3D objects made of faces which cannot 'see' each other. Most commonly, you will use cubes or cuboids, but know that any convex polyhedron is allowed.

It's ok if your head is spinning from reading all that, even if you don't fully understand that definition, using brushes in Quake editing software is easy, and the hard work of mathematically defining them is done for you, hidden away in the background. All you need to do is plop them down, and arrange them to make the walls and floors of your level!

Entities: The life of the party

A few entities

So we have brushes to define our world's geometry... but it wouldn't be a Quake level without weapons and monsters! And entities are just that, they are any of the functional objects defined in the game code for you to place into your level.

There are 2 types of entities: Brush entities and Point entities. Brush entities are things like doors, platforms, and trigger volumes; they are any functional object which need brush geometry tied to them to do their job. Point entities are things like weapons, monsters, and lights; they are all objects which are just simply dropped into place (at a point) in the world.

Entities of both types have various properties that can be edited by the designer to modify specified effects on the entity. Each property is a combination of a 'Key', which is the name of the properties, and it's 'value'.

Textures Wads and Compilers

Some textures

To round out our definitions, let me also talk about some external things we will need along with our .map file to create our final .bsp level.

Each face of a brush is allowed 1 texture, which can be rotated, scaled, and translated. But where do we get our textures? They are stored in .wad files, which are a collection of textures to be used in levels. If you are familiar with older Doom/Doom2 level design, these are NOT the same as their WAD files, despite having the same name.

We also need compilers, which take our raw .map file and turn it into a .bsp file which Quake can load. There are 3 compilers which are used: QBSP, which turns the .map into a .bsp. Light, which calculates all the lighting information in the .bsp using our .map's instructions. And Vis, which calculates visibility in the level to optimize Quake's rendering.

Tools of the trade

Now that we have definitions out of the way, let's get all the tools we will need.

Editing Software: This tutorial will use Trenchbroom. [Homepage]

A texture .wad: We will use Q.wad, which are all the textures from Quake. [Download]

Map compiler tools: This tutorial will use Tyrann's TyrUtils. [Homepage]

Necros's CompilingGUI (optional): This is a handy front end for the compilers so you do not have to use command prompt or batch files to run the compilers. [Homepage]

Trenchbroom you will need to install, the others are loose files which you will need to put somewhere accessible. I personally have a folder on my hard drive E:\q1maps\ where I keep all my .wads, compiling tools, .maps, etc.

Putting it together.

Now that we have definitions out of the way, let's actually build a simple level. (TODO: Actually write stuff here and take screenshots and such)