8.3 KiB
Quake
Quake, released in 1996 (as shareware, originally for DOS and Winshit), is one of the best and most influential first man video games ever produced, released as the next big game by the creators of Doom (Id Software), notable not only for once again pushing 3D graphics yet to another level, but equally so for introducing gameplay, mechanics and even "accidental features" (bugs) that practically started a new genre. The original game has since been spawning sequels: Quake II (1997), Quake III Arena (1999, purely multiplayer), Quake IV (2005), Quake Live (2014, basically Quake III HD) and Quake Champions (2022, shit that practically killed the series). This article will mostly focus on the original game as it's most notable and very technologically interesting.
{ Some online resources on Quake: https://quakewiki.org/wiki/, https://www.gamers.org/dEngine/quake/. ~drummyfish }
Of course the game is proprietary, but the engine was later released as free software under GPL, which gave birth to a plethora of source ports and even completely libre games such as Xonotic. This is one reason for why there are still big fan communities around Quake to this day, mainly centered around competitive multiplayer and speedrunning.
Upon its release Quake was a hit -- maybe not as huge as Doom, but that's perhaps only because Doom came first, struck like lightning and had little competition. Unlike Doom, Quake also wasn't universally revolutionary, its single player, enemies and music weren't as memorable, but the more innovation it brought in the area of graphics and competitive multiplayer where fast, skillful movement was as key to success as accurate aim. While Doom utilized a "primitive/pseudo 3D" graphics with 2D enemy sprites and limitations imposed on level geometry, Quake engine implemented what we now call a "full/true 3D", i.e. it allowed unrestrained camera rotation and levels featuring all kinds of shapes, including sloped floor and ceiling, rooms above other rooms, walls moving in any direction etc. Still by historical significance this has now been overshadowed by an incredibly addictive player movement mechanisms that Quake invented (partially through bugs that turned out to add to the gameplay), a formula that's still being replicated today. In Quake movement is art and science in itself and this went as far as to spawning entire communities that essentially modded the game to become a racing game without any shooting, purely focusing on movement (see the defrag mods). Most notable are such techniques as bunny hopping (jumping during movement, increasing speed), strafe jumping (turning diagonally when bunny hopping, adding velocity, which actually wasn't intended by developers), rocket jumping (shooting rockets under own feet to jump higher), circle jumping, air control, landing on slopes to gain speed, and there are many more.
Just like with Doom, the game's plot is simple and gives way to gameplay, it revolves around some kind of badass soldier (the player) stopping an invasion led by an extraterrestrial oppressor codenamed Quake. The game's atmosphere is dark, medieval, violent and scary, emphasizing brutality and gore, visibly influenced by H. P. Lovecraft. Iconic were also the weapons of which there weren't many (8 in total), but which were very diverse. Each weapon had a specific use and most of them became a standard arsenal of arena shooter games, notably the shotgun, rocket launcher, grenade launcher and lightning gun.
Code And Technical Details
In general the game is no longer as nice in its internals as Doom was, creeping of mainstream capitalist bullshit already started to show here.
The engine, also known as Id Tech 2, is written in C89. The original source code release has just short of 100 KLOC. That's no longer really suckless. The code itself looks alright, has consistent formatting and comments. The game was developed on NeXTSTEP. The engine is built around client-server architecture and allows a multiplayer of up to 32 players.
Quake engine features one highly embarrassing feature: a kind of scripting language called QuakeC (see also HolyC). This language compiled to bytecode and allowed to mod the game without recompiling the engine (a feature that Doom engine lacked), which sounds cool and all, but it's shit: it's a new language, new compiler and huge bloat.
Sadly the game also uses float, another thumbs down.
The engine is also fucking nondeterministic, mainly because its physics is FPS dependent (huge brain fart), but even if that was fixed it might not suffice e.g. because of the use of floating point (as C specification leaves room for floating point nondeterminism).
And as if that wasn't enough, the demo format sucks ass too. While demos in Doom only recorded the player's inputs -- the way it should always be done -- Quake demos literally store the player states such as their positions etc. It's basically a recording of packets coming from the server to the client. This means the demos are bigger, information about input is lost (causing trouble in verifying speedruns for example) and the demo is only playable from point of view it was recorded from. This desperate and disastrous design choice had to be made because the engine is nondeterministic. Here we can see how a bad programming choice quickly snowballs into a gigantic pile of shit.
As for the 3D rendering: this is probably the nicest part. The engine features a beautifully looking software renderer that was very fast (optimized in assembly). It supported 256 colors and by default ran in 320x200 resolution that computers back then could handle at 30 FPS. Shortly after the game's release new versions added a support for GPU acceleration with OpenGL, which was of course faster, additionally supported 16 and 32 bit color, higher resolution and pimped up look (transparent water, bilinear texture filtering that actually looks inferior and soulless, ...). We'll be however focusing on the software renderer. It used Gouraud shading for moving objects (enemies, doors, ...) and precomputed lightmaps for static environment. Just like Doom, BSP trees were still used to represent levels, however in Quake they were 3D (while in Doom only 2D). The renderer worked as follows. First frustum culling was performed on the BSP tree, removing anything not in the direction of the camera. Secondly there were precalculated potentially visible sets (PVS) -- a data structure storing information about which BSP leaves are visible from other leaves, allowing for saving time by disregarding most parts of the level that can't be seen -- this was applied after frustum culling. Backface culling followed and then rasterization itself in front-to-back order. Rasterization was made so as to eliminate overdraw, it was quite complex, based on scanlines formed by projected geometry edges. As another improvements against the Doom engine there were simple particle systems (well, literally just tiny squares), real-time lighting, warping screen effects and fully 3D animated enemy models. Animated models used a MDL format which stored simple vertex animation (no skeletal bullshit) -- the frames were just played one after another without interpolation, resulting in a "jerky" animation. Needless to say the models were quite low poly (monsters usually around 300 triangles) and had quite low-res textures (around 300x200 pixels).
See Also
- Doom
- Duke 3D
- Chasm the Rift (contemporary, less well known competitor)