Series

Quake

7 games, 1996–2018.

Games

Mechanics

Mechanic	Quake 1996	Quake II 1997	Quake III Arena 1999
Air control	Momentum	Momentum	Momentum
Bunny hopping	Landing friction	Frictionless	Frictionless
Damage formula		Base plus a roll
Demo playback	Recorded state
Difficulty level		Damage halved
Gravity	One gravity
Hitscan		Hitscan beside projectiles
Jump	One speed	One speed	One speed
Monster infighting		Same kind
Pain chance		Cooldown
Rocket jumping		Boosted self-push
Running	Momentum	Momentum	Momentum
Strafe-running	Air strafe	Angled air strafe	Angled air strafe
Weapon pickup		Inventory

A marked cell changed from the game before. “Uses” means the game has the mechanic, with no variant recorded yet.

Every claim, by mechanic and game

Concept	Quake 1996	Quake II 1997	Quake III Arena 1999
Air control	uses	uses	uses
Bunny hopping	Because Quake runs friction in `SV_ClientThink` before the QuakeC jump in `PlayerPreThink`, and the on-ground flag is set by the walking move when it ends on a floor, a jump can come no sooner than the frame after landing, and that frame takes ground friction first: computed, a hop loses 4/72 of its horizontal speed (5.6%) at 72 frames a second above 100 units/s, or 8/72 (11.1%) when no floor lies within 34 units below a point 16 units ahead. Code QuakeWorld's `pmove.c` checks the jump before friction: `PlayerMove` calls `JumpButton`, which clears `onground`, and then `PM_Friction`, whose ground friction runs only while `onground` is set, so a QuakeWorld hop on its first ground frame loses no speed to friction, where WinQuake's takes one frame of it (quake/hop-friction). Both still need the button released between jumps, and both add 270. Code	Quake II checks the jump before friction: `Pmove` calls `PM_CheckJump`, which clears the ground entity, and then `PM_Friction`, whose ground friction needs a ground entity, so a hop on the first command that starts on the ground loses no speed to friction. QuakeWorld's `PlayerMove` has the same order: `JumpButton` clears `onground` before `PM_Friction`, whose ground friction needs it. Two conditions apply. The jump key must be released and pressed again (the jump claim). And when the position check first finds ground with the vertical speed below −200, it sets a landing timer of 18 units, or 25 below −400, that blocks the jump until it runs out; each command lowers it by its length in ms divided by 8, rounded down and at least 1, so 18 units last 144 ms at 8 or 16 ms commands and 180 ms at 10 ms (computed). By the atlas's reading the slide move clips the velocity along a floor it runs into, and the stepping move keeps that clipped vertical speed, so a landing step that reaches the floor would not set the timer; how often a hop's landing sets it has not been measured. Code	Quake III checks the jump before friction: each step, `PmoveSingle` traces for ground before the move, `PM_WalkMove` calls `PM_CheckJump` before `PM_Friction`, and a jump clears the walking flag and hands the step to `PM_AirMove`, whose friction call skips ground friction without that flag. So a hop on the first step that starts on the ground loses no speed to friction, as in QuakeWorld (quake/qw-hop-friction), where WinQuake's takes one frame of it, 5.6% at 72 frames a second (quake/hop-friction). The hop needs the jump key released and pressed again in the air, as in both. Code
Damage formula		A Quake II rocket's direct hit does 100 + `(int)(random() * 20.0)` damage, 100 to 119, the roll made when it is fired; the explosion then does radius damage to everything else within 120 units, the rocket's 120 less half the distance from the explosion to the center of the target's box, and the target hit directly takes no splash. A quad damage multiplies both by 4. The railgun's damage is a constant, 150 in single player and 100 in deathmatch. Code Quake II's `T_Damage` doubles the damage a player does to a living monster that has no enemy yet, commented "bonus damage for suprising a monster", unless the damage is radius damage; the doubling comes after Easy's halving, which applies only to players. Code
Demo playback	A Quake demo (`.dem`, WinQuake source) opens with a line of text, the CD track to force or -1, and then holds one block for each message the server sent, except one-byte keepalives (`svc_nop`), which are dropped: its length in 4 bytes, the client's three view angles as 4-byte floats, and the message itself. `stop` ends the recording with one last block holding a disconnect message. Code A Quake demo records what the server told the client, not the player's inputs. Playing one first disconnects from any server, shutting down a local one, and the client then reads its server messages from the file instead of the network and parses them as live ones; the file's view angles set the view. No server runs during playback; the world arrives as the recorded messages. Code Playback reads the next block only once the client's clock passes the time stamped in the last message (`svc_time`), so a demo plays at its recorded speed; `timedemo` instead reads one block a frame and reports frames, seconds, and frames per second. The file's closing disconnect ends the game, and while the attract loop runs the next demo of the `startdemos` list, up to 8, starts. Code
Difficulty level		On Easy (skill 0) outside deathmatch, Quake II's `T_Damage` halves the damage a player takes, to no less than 1; the knockback is worked out separately and isn't halved. Levels also pick their entities by skill: an entity flagged not-easy, not-medium, or not-hard is removed at load on that skill, with Nightmare (3) counted as hard. Code
Gravity	Quake's gravity is the cvar `sv_gravity`, defaulting to 800, and each level's QuakeC `worldspawn` sets it to 800 again, or to 100 on E1M8; every frame a walking player is not in water (water level 2 or more) or a water jump, `SV_AddGravity` takes the entity's gravity field (1 when unset) × `sv_gravity` × frame time off its vertical velocity, on the ground as well as in the air. Code
Hitscan		Quake II's bullets, pellets, and railgun are hitscan: `fire_lead`, which `fire_bullet` (the machine gun and chaingun) and `fire_shotgun` (once per pellet, for both shotguns) call, traces a line 8192 units long in the frame the gun fires, bent by a random spread (`crandom` × the spread, each way) for each bullet or pellet, and `fire_rail` traces 8192 units and keeps tracing past every monster or player it hits, damaging each. The blaster, grenades, and rockets launch entities that travel: the player's blaster bolt at 1000 units/s, the launcher's grenade at 600, and the rocket at 650. Code
Jump	Quake's jump is QuakeC (1.01's `client.qc`): each frame `PlayerPreThink` calls `PlayerJump` while the jump button is held and otherwise sets `FL_JUMPRELEASED`; on land (water level under 2, not in a water jump), `PlayerJump` acts only when the player is on the ground and has released the button since the last jump, then clears both flags and adds 270 to the vertical velocity. Holding the button never jumps twice. Code Computed from the jump and gravity, ignoring frame steps: a Quake jump from flat ground at the default gravity of 800 rises 270² / (2 × 800) ≈ 45.6 units and lands after 2 × 270 / 800 = 0.675 seconds. Code	Quake II's `PM_CheckJump`, which `Pmove` runs before friction, does nothing while the landing timer flag is set; otherwise it needs an up move of at least 10 and the jump-held flag clear, which only a command with the key released clears, so holding the key never jumps twice. On ground it adds 270 to the vertical velocity, raising it to at least 270, and clears the ground entity; in water at level 2 or more it sets an upward swim speed instead (100 in water, 80 in slime, 50 in lava). Quake's QuakeC jump and QuakeWorld's movement code also add 270. Gravity is `sv_gravity`, 800. Code	Quake III's jump is in the shared movement code: `PM_CheckJump`, called from `PM_WalkMove` (so only on walkable ground), needs an up move of at least 10 and the jump-held flag clear, which `PmoveSingle` clears only on a step whose up move is under 10, so holding the key never jumps twice; it then sets the vertical velocity to `JUMP_VELOCITY` (270), where Quake's QuakeC adds 270 to it (quake/jump). Gravity is `g_gravity`, 800, as in Quake. A landing from a fall faster than 200 units/s sets a land timer of 250 ms that a comment says is to "not allow another jump for a little while", but `PM_CheckJump` never tests it. Code
Monster infighting		When a monster survives damage from another monster, Quake II's `M_ReactToDamage` makes the attacker its enemy if both move the same way (walking, flying, or swimming), their class names differ, and the attacker isn't a tank, super tank, Makron, or Jorg; failing that, it fights back only if the attacker was targeting it, and otherwise takes on the attacker's enemy, unless that enemy is itself. Nothing happens when it hurt itself or the attacker is already its enemy. A player it was chasing is kept as the old enemy. Quake's rule, in the version 1.01 QuakeC of id's Quake-Tools release, is simpler: a monster turns on any attacker of a different class, and soldiers turn on each other too. Code
Pain chance		In the four Quake II monsters read, a flinch is a cooldown rather than a roll: the soldier's, infantry's, and gunner's pain functions play a pain animation unless one started within the last 3 seconds (`pain_debounce_time`), choosing which at random (soldier, infantry) or by the damage (gunner), and on Nightmare (skill 3) they return before the animation. The soldier has an exception both ways: knocked upward faster than 100, it switches to a fourth pain animation even within the cooldown (if already in one of the other three) and even on Nightmare. On Nightmare the cooldown is 5 seconds, not 3: `T_Damage` resets it to 5 after each hit that calls the pain function. The tank adds a roll: it ignores hits of 10 or less, and flinches from 11 to 30 only when `random()` is at most 0.2; on hard and Nightmare it doesn't flinch during two of its attacks. Code
Rocket jumping		Quake II's radius damage halves the points for the entity that caused it, so a player takes half splash from their own rocket or grenade, and `T_Damage` pushes a player who hurt themselves with 1600 × knockback / mass instead of 500 ×, commented "the rocket jump hack...". The player's mass is 200, so a self-inflicted push is 8 units/s per point against 2.5 from anyone else, and the radius damage passes its points as the knockback. Computed: a rocket exploding on the floor directly under a standing player, 28 units below the center of the player's box, does 120 − 14 = 106, halved to 53, which adds 424 units/s upward, against a jump's 270. Code
Running	On the ground, Quake's `SV_UserFriction` takes the horizontal speed and lowers it by frame time × friction × the larger of the speed and `sv_stopspeed`, to no less than 0, scaling all three velocity axes by the same factor; `sv_friction` defaults to 4 and `sv_stopspeed` to 100, and when a trace 16 units ahead along the motion finds no floor within 34 units below the feet, the friction is multiplied by `edgefriction` (default 2). A standing player is left alone. Code Quake builds the wish velocity from the forward and side moves along the view's forward and right vectors (zero vertical for a walking player), caps its length at `sv_maxspeed` (default 320), and on the ground runs friction and then `SV_Accelerate`: if the speed along the wish direction is under the wish speed, it adds `sv_accelerate` (default 10) × frame time × wish speed along that direction, no more than the shortfall. Code Computed from the friction and acceleration rules, not measured: because acceleration (10) outpaces friction (4), a Quake player on flat ground settles at exactly the wish speed, 320 units/s at a run; at the 72-frame rate a run from rest reaches it on frame 10 (0.14 s), and letting go from 320 comes to rest after 39 frames (0.54 s). Code	On the ground, Quake II's `Pmove` runs `PM_Friction`, which lowers the speed by step time × 6 (`pm_friction`) × the larger of the speed and 100 (`pm_stopspeed`) on any ground that isn't slick, and then `PM_Accelerate` with `pm_accelerate` 10: if the speed along the wish direction is under the wish speed, it adds 10 × step time × wish speed, no more than the shortfall. The wish velocity's length is capped at 300 (`pm_maxspeed`), or 100 ducked. These are the numbers Quake III keeps (friction 6, acceleration 10), where Quake's friction is 4. Computed, not measured: since 10 outpaces 6, a run settles at exactly 300 units/s. The movement constants are C globals, not cvars. Code	On the ground, Quake III's `PM_Friction` takes the horizontal speed and lowers it by step time × `pm_friction` × the larger of the speed and `pm_stopspeed`, scaling all three velocity axes by the same factor, with `pm_friction` 6 and `pm_stopspeed` 100 set in the code; it skips ground friction in water deeper than level 1, on a slick surface, and while the knockback timer runs, and it has no edge friction. Quake's ground friction is the same rule with friction 4 (`sv_friction`) and the same stop speed, doubled over a ledge (quake/ground-friction). Code Quake III's `PM_WalkMove` runs friction and then `PM_Accelerate` with `pm_accelerate` 10, which is Quake's rule (Quake III's `PM_Accelerate` comment says "q2 style"): if the speed along the wish direction is under the wish speed, it adds 10 × step time × wish speed along that direction, no more than the shortfall. The full wish speed is the player's `speed`, set before each move from `g_speed` (320, × 1.3 with Haste). Computed, not measured: since 10 outpaces the friction of 6, a run settles at exactly 320, as Quake's does at 10 against 4; at 8 ms steps it reaches 320 from rest in 19 steps (0.15 s) and stops from 320 in 45 (0.36 s). These figures leave out the rounding `trap_SnapVector` applies to the velocity after each step, engine code the atlas hasn't read. Code
Strafe-running	Quake's keyboard moves are `cl_forwardspeed` and `cl_backspeed` 200 and `cl_sidespeed` 350, doubled by the run key (`cl_movespeedkey` 2.0), and the menu's "always run" sets forward and back to 400. Computed from these and the 320 cap: walking forward wishes 200, while a strafe alone (350), a walk with a strafe (√(200² + 350²) ≈ 403), and any run all wish 320. Code In the air, Quake's `SV_AirAccelerate` takes the wish velocity's direction and length, caps that length at 30, and adds speed along the wish direction only while the velocity's component along it is under 30: the push is `sv_accelerate` × the uncapped wish speed (up to 320) × frame time, cut to the shortfall below 30. There is no friction in the air. Code Computed from `SV_AirAccelerate`, not measured: with a wish speed of 320 the push can reach 10 × 320 × frame time (44.4 at 1/72 s, more at longer frames), so a frame lifts the velocity's component c along the wish direction to 30 whenever c is between −14.4 and 30, and the new speed is √(v² + 900 − c²) for speed v. That is largest with the wish at 90° to the motion: each frame then adds √(v² + 900) − v, 1.40 units/s at 320 and 0.90 at 500, and turns the motion by atan(30/v), 5.4° per frame at 320. At 72 frames a second that is about 101 units/s gained per second at 320. Code QuakeWorld's `PM_AirAccelerate` keeps WinQuake's air rule unchanged: the wish speed capped at 30 for the shortfall test, and the push from the uncapped wish speed × acceleration × frame time; it adds only an early return for a dead player or a water jump. Code	Quake II's keyboard moves are `cl_forwardspeed`, `cl_sidespeed`, and `cl_upspeed` 200, all doubled while running, which the speed key toggles: with `cl_run` 0 holding the key runs, and with `cl_run` 1 holding it walks. The movement code builds the wish velocity from the view's forward and right vectors, with the pitch first divided by 3, then zeroes its vertical part and caps its length at 300. Computed from these, with the view level (pitch 0): walking forward wishes 200 and walking forward with a strafe about 283, but a run wishes 400 forward and about 566 on the diagonal, both cut to 300, so a strafe adds nothing to a run on the ground. Looking up or down shortens the forward part before the cap. Code In the air, Quake II's `PM_AirMove` calls the ground's `PM_Accelerate` with an acceleration of 1 while `pm_airaccelerate` is 0: the push is 1 × step time × wish speed (up to 300), and it stops only when the velocity's component along the wish direction reaches the full wish speed. Quake III keeps this rule, with `pm_airaccelerate` 1 and a `PM_Accelerate` commented "q2 style". In deathmatch the server copies its latched cvar `sv_airaccelerate` (default 0) into `pm_airaccelerate`, and any nonzero value switches to `PM_AirAccelerate`, which is Quake's air rule: the wish speed capped at 30 for the shortfall, the push from the uncapped wish speed × `pm_accelerate` (10) × step time. The server's movement code uses the value only as a nonzero test, so it acts as an on-off switch; outside deathmatch it is forced to 0. The server also sends the value to clients as the `CS_AIRACCEL` config string, for their prediction, in code not read here. Code	Quake III's keyboard moves are 127 per axis at a run (the speed key or `cl_run`, one but not both) and 64 at a walk, and `PM_CmdScale` scales the wish so its length is the player's speed × the largest of the forward, side, and up moves ÷ 127, which a comment says avoids "a sqrt(2) distortion in speed": at a run, forward, a strafe, and both together each wish 320, so a strafe adds no ground speed, where Quake's walk with a strafe wishes 320 against 200 (quake/move-speeds). The up move counts too: computed, holding the jump key (up move 127) in the air with forward and a strafe wishes 320 × √2/√3 ≈ 261. On the ground `PM_CheckJump` zeroes a held jump's up move, and `Pmove` lowers it to 20 for the later steps of a command it splits. The figures leave out the rounding `trap_SnapVector` applies to the velocity after each step, engine code the atlas hasn't read. Code In the air, Quake III's `PM_AirMove` runs friction (no ground friction, which needs the walking flag), builds a flat wish velocity, and calls the same `PM_Accelerate` as the ground with `pm_airaccelerate` 1: the push is 1 × step time × wish speed (2.56 units/s per 8 ms step at 320), and it stops only when the velocity's component along the wish direction reaches the full wish speed. Quake's air rule is the reverse: a push ten times as strong (10 × 320 × frame time), cut off when that component reaches 30 (quake/air-accelerate). An `#else` branch left out by `#if 1` would push the velocity toward the wish velocity instead, commented "proper way (avoids strafe jump maxspeed bug), but feels bad". The figures leave out the rounding `trap_SnapVector` applies to the velocity after each step, engine code the atlas hasn't read. Code Computed from `PM_Accelerate` with `pm_airaccelerate` 1, not measured: at a wish speed W of 320 (forward and a strafe at a run, the jump key up, no Haste) the air push is W × step time, a = 2.56 per 8 ms step, and the cap leaves room for all of it while the velocity's component c along the wish direction is at most W − a; the new speed √(v² + 2ca + a²) is then largest at c = W − a, with the wish 7° off a 320 motion, 37° off 400, and 51° off 500. Each 8 ms step adds 2.54 units/s at 320 and 1.63 at 500, about 317 and 204 units/s each second, close to W²/v at any step length (316 at 1/72 s). Quake's gain is fixed per frame instead, about 101 units/s each second at 320 at 72 frames a second (quake/air-strafe-gain). The figures leave out the rounding `trap_SnapVector` applies to the velocity after each step, engine code the atlas hasn't read. Code
Weapon pickup		A Quake II weapon pickup adds the weapon to the player's inventory, which keeps every weapon taken, and gives that weapon's ammo with it unless the item carries the `DROPPED_ITEM` flag. The player switches to it only when it is the first of its kind carried, and in deathmatch only while the blaster is in hand. In coop, or in deathmatch with weapons-stay set, a player who already has the weapon can't take a placed one. A placed weapon picked up in deathmatch stays where it is with weapons-stay set and otherwise respawns after 30 seconds, and in coop it stays; a weapon flagged `DROPPED_PLAYER_ITEM`, which a dying player's weapon is, gives its ammo but neither stays nor respawns. Code