Destructible terrain

On this page

How it works
Quirks
History
Related
Games
References
Sources

Destructible terrain is level geometry that play changes: shields that wear away, bricks that break, ground that is dug out or blown into craters. In Space Invaders the shields are pixels on the screen, and a shot’s explosion erases a pattern of them¹. In Super Mario Bros. a brick is a tile, there or gone, and only big Mario breaks one². Red Faction cuts the shape of each explosion out of its 3D walls and floors³.

Dwarf Fortress (2006). Dwarves dig out any tile the player marks, on any level of a three-dimensional map; mining clears the wall, and channelling takes the floor as well.^4,5
ErodesSpace Invaders (1978). The shields are screen pixels; a shot's explosion pattern is erased from them, and aliens drawn over them overwrite them.^6,7,1,8,9
Dug and refillsLode Runner (1983).¹⁰
Breakable tilesBomberman (1985).¹¹Super Mario Bros. (1985). Big Mario breaks a plain brick he hits from below; small Mario only bumps it, and either size only bumps a ? block.^{2,12,13,14,15}Mega Man 6 (1993). The Power adaptor's punch breaks cracked stone walls.¹⁶Infiniminer (2009). The pickaxe digs dirt, ore, gold, and diamonds out a block at a time; rock gives way only to a Sapper's explosives.^17,18Minecraft (2009). Every block but a few, such as bedrock, can be broken; a hard one broken with the wrong pickaxe leaves nothing behind.^19,20,21
DeformsScorched Earth (1991).²²Worms (1995).²³
StructuralRed Faction (2001).³Battlefield: Bad Company (2008).²⁴

#How it works

#Space Invaders (1978)

The shields are not objects. Each player’s four shields live in a RAM buffer, copied from one 22 × 16 px image, and the game ORs them onto the 1-bit screen at the start of a turn⁶. Nothing tests for a shield as such. Every shot is drawn with a routine that checks its pixels against what is already lit, and any overlap counts as a hit⁷.

every step of a shot:                               # MovePlyShot / HandleAlienShot
    erase the shot (AND NOT its pixels)
    move it
    draw it (OR), noting whether any pixel was already lit
    if one was: start the explosion

the explosion:                                      # GameObj1 status 3 / ShotBlowingUp
    erase the shot
    draw the explosion pattern (OR)
    after the blow-up timer: erase the pattern (AND NOT)

Erasing with an inverted AND clears every lit pixel under the pattern, shield pixels included, so the hole is the explosion’s shape. The player’s shot leaves an 8 × 8 px pattern with 38 set bits¹. An alien shot leaves a 6 × 8 px pattern of 26⁸. The player’s shot moves 4 px a step and is 4 px long, so it meets every pixel row on its path⁷.

Aliens erase shields too. The routine that draws an alien stores its bytes over the screen instead of ORing them in, so wherever an alien passes, its own image and blank pixels replace the shield’s⁹. In a two-player game each player’s shields are copied back to that player’s buffer at the end of a turn, so damage carries over until the next rack⁶.

#Super Mario Bros. (1985)

Mario’s head is one point, 8 px in from his left edge, tested after the frame’s movement while he moves up²⁵. Only the block under that point can be hit, so when his head spans two blocks the other one is ignored. A block in the solid ranges stops him: his vertical speed becomes 1 px/frame, with no push out of the block²⁶. Bricks, ? blocks, and hidden blocks are hit instead¹⁴.

after the frame's move, while moving up:            # PlayerBGCollision → PlayerHeadCollision
    m = metatile at (x + 8, head y)
    if m is nothing or a coin, or Y's low nybble < 4: skip
    if m is solid, a bounce is under way, or water:  # BlockBounceTimer
        y speed = 1
    else if big and m is a plain brick:              # not in BrickQBlockMetatiles
        break it: y speed = -2, cell -> $23, then empty next frame
    else:
        bump it: y speed = 0, cell -> $23 while the block bounces
    start BlockBounceTimer at 16

Big Mario breaks a plain brick; anything else, and anything small Mario hits, is bumped². A bump sets Mario’s vertical speed to 0 and throws the block up 8 px and back in 14 frames. Its cell then holds a used block, or the brick itself when small Mario hit it¹³. For 16 frames after any hit, no other block can be bumped or broken²⁷. The bouncing block is a sprite. Collision uses its cell, which holds an invisible solid block until the bounce ends²⁸.

A break scores 50 points and throws four chunks of debris^12,29. The chunks start up at 6 and 4 px/frame²⁹. A brick with coins pays out until a timer of 211 to 231 frames runs out³⁰.

#Other games

Lode Runner’s NES booklet lets the player drill only through fissured bricks, and the holes fill in again after a time, killing any guard still inside¹⁰. Jimmy Maher puts the refill at ten seconds³¹. Bomberman’s booklet has bricks that bomb flames dissolve, hiding exits and power-ups, and concrete walls that bombs don’t damage¹¹.

In Scorched Earth, whole classes of weapons remove dirt or add it, and dirt left hanging normally falls²². The Worms manual’s Bazooka damages the terrain, and its Blowtorch and Drill dig through it²³.

Red Faction’s Geo-Mod system subtracts a low-polygon shape that mimics the explosion from the world’s geometry³. Battlefield: Bad Company let players destroy parts of walls and vehicles²⁴.

#Quirks

Big Mario can break the ground. The overworld’s ground block is in the same range as bricks, so the game breaks it like one¹⁵.
A break doesn’t let Mario through. The cell is cleared only after the next frame’s head check, which meets the invisible block and stops the jump one frame later¹².

#History

Space Invaders’ shields are the earliest case read in code here¹. Ben Lindbergh’s 2024 survey for The Ringer sets 3D destruction against the “primitive environmental mayhem” of Dig Dug, Rampage, and Worms³². Worms’ programmer, Andy Davidson, traces the game to the artillery games of the 8-bit era and to his interest in generating random terrain³³.

Red Faction’s lead designer, Alan Lawrance, says that when Volition looked for games with destruction on that scale, “there really wasn’t anything”³⁴. Its lead programmer, John Slagel, had written a crater-bombing game on an IBM PCjr as a teenager³⁵. At DICE, Karl-Magnus Troedsson says destruction came from looking for a way to stand apart³⁶. Alan Kertz says no one was doing it in multiplayer before Battlefield: Bad Company³⁷.

The Legend of Zelda’s NES booklet describes the bomb only as a weapon and leaves hidden doors “a secret”³⁸.

Games

Game	Year	How	Note
Dwarf Fortress	2006		dwarves dig out any tile the player marks, on any level of a three-dimensional map; mining clears the wall, and channelling takes the floor as well
Space Invaders	1978	Erodes	the shields are screen pixels; a shot's explosion pattern is erased from them, and aliens drawn over them overwrite them
Lode Runner	1983	Dug and refills
Bomberman	1985	Breakable tiles
Super Mario Bros.	1985	Breakable tiles	big Mario breaks a plain brick he hits from below; small Mario only bumps it, and either size only bumps a ? block
Mega Man 6	1993	Breakable tiles	the Power adaptor's punch breaks cracked stone walls
Infiniminer	2009	Breakable tiles	the pickaxe digs dirt, ore, gold, and diamonds out a block at a time; rock gives way only to a Sapper's explosives
Minecraft	2009	Breakable tiles	every block but a few, such as bedrock, can be broken; a hard one broken with the wrong pickaxe leaves nothing behind
Scorched Earth source	1991	Deforms
Worms source	1995	Deforms
Red Faction source	2001	Structural
Battlefield: Bad Company source	2008	Structural

Every claim about this mechanic, by game (36)

Space Invaders 1978	The shields are pixels in the 1-bit screen bitmap, not objects. Each player has a RAM buffer of four copies of the 44-byte `ShieldImage`, 22 rows of 2 bytes, a 22 × 16 px shape of 294 lit pixels (computed); `RestoreShields` ORs the buffer onto the screen, the four shields with 23 rows between them (45 from start to start), and in a two-player game `RememberShields` copies them from the screen back into the player's buffer, so each player keeps their own damage. The buffers are redrawn from the image at the start of a game and with each new rack.	Code
	Nothing tests for shields as such. Every shot is drawn with `DrawSprCollision`, which ANDs each byte of the shifted sprite with the screen before ORing it in and sets the collision flag if any pixel was already lit, so a shot hits a shield when its newly drawn sprite overlaps a lit shield pixel. The player's shot is 1 px wide and 4 px long and moves 4 px a step, so it is tested against every pixel row on its path (computed). A player's shot that collides below the rack takes status 3, the code for a hit on something other than an alien.	Code
	A player's shot that hits a shield erases itself, then ORs the 8 × 8 px `ShotExploding` pattern onto the screen around the point of impact; after the blow-up timer counts down from 16, `EndOfBlowup` erases that pattern with an inverted AND. The erase clears every pixel under the pattern's 38 set bits (computed), shield pixels included, and the first erase had already cleared the shield pixels under the shot itself, so the hole is the explosion's shape plus the shot's last 4 px.	Code
	An alien shot ends when its newly drawn sprite collides with any lit pixel, or when it falls below the playfield; a collision at the player's height kills the player instead. Its blow-up timer starts at 4: on the first tick `ShotBlowingUp` erases the shot and draws the 6 × 8 px `AShotExplo` pattern, and on the tick that reaches 0 it erases that pattern with an inverted AND, so a shield loses the pattern's 26 pixels (computed) plus those under the shot itself.	Code
	Aliens that reach the shields erase them. `DrawSprite`, which draws each alien, stores the shifted sprite bytes over the screen instead of ORing them in, both bytes of each of its 16 rows, so wherever an alien is drawn the shield pixels in those bytes are replaced by the alien's image and its blank pixels. The disassembly's comment on `CodeBug1` describes a lone alien that "enters the players shields on the lower left where it begins to eat them".	Code
Lode Runner 1983	The NES Lode Runner booklet says the player may drill only through fissured bricks, not solid surfaces, and that drilled holes fill in again after a period of time; guards caught in a hole when it refills die and are replaced by new guards at the top of the screen.	Manual
Lode Runner 1983	Jimmy Maher's history of Lode Runner says drilled pits fill in again after ten seconds, and that monks (the guards) climb out of a pit in a few seconds, so a pit that closes while a monk is still inside buries him.	Web
Bomberman 1985	The NES Bomberman booklet describes two kinds of wall: bricks, which the flames of exploding bombs dissolve and which hide the exitways and power-up panels, and concrete, which bomb fire doesn't damage, so Bomberman can shelter behind it.	Manual
Super Mario Bros. 1985	While Mario moves up, `PlayerBGCollision` tests a single head point, the first of its point set (smb1/bg-points), after the frame's movement and before the feet. It acts only if his vertical speed byte is negative, the low nybble of his own Y is 4 or more, and his Y is at least `$20` (big) or `$10` (small, or big and crouching), and only if the point's metatile is nonzero and not a coin. So one block at most is hit per frame: when his head spans two blocks, the one under the point is hit and the other is ignored. Measured: big Mario under a brick that covered only his box's left part rose past it untouched.	Verified
	`CheckForSolidMTiles` splits what a head can meet by the metatile's top two bits: at or above `$10`, `$61`, `$88`, or `$C4` in its group is solid (smb1/head-solid); below is hit (`PlayerHeadCollision`). The collision map stores nothing below `$10`, `$51`, `$88`, and `$C0` in the same groups, so the hit kinds are `$51`–`$60` (bricks, the cracked-rock ground, bricks with items, hidden blocks) and `$C0`–`$C1` (? blocks); a used block (`$C4`), the solid blocks from `$61`, and pipes are solid.	Code
	`PlayerHeadCollision` bumps the block unless Mario is big and the metatile is missing from `BrickQBlockMetatiles`, the list of ? blocks (`$C0`, `$C1`), hidden blocks (`$5F`, `$60`), and bricks with items (`$55`–`$5E`); then it breaks it (smb1/brick-break). So big Mario breaks plain bricks (`$51`–`$53`) and bumps the rest, and small Mario bumps everything. Size is `PlayerSize`, so by the code a crouching big Mario breaks bricks too (not probed). Measured: big Mario, standing, broke a brick and bumped a ? block and a hidden block; small Mario bumped a brick and a ? block.	Verified
	A bump (`BumpBlock`) sets Mario's vertical speed byte to 0, keeping the fraction, and starts a block object at the block's row moving up at 2 px/frame under a gravity of `$50`/256 px/frame². The object moves on the hit frame itself, after the player; measured against its row, it reads −2, −4, −6, −7, −7, −8, −8, −8, −7, −6, −5, −4, −2, 0 px on the hit frame and the 13 after, and it ends when its Y's low nybble is under 5. The block's cell holds `$23` from the hit frame, and the next frame's `BlockObjMT_Updater` writes the block back: a used block (`$C4`) for ? blocks, hidden blocks, and item bricks, the metatile itself for a plain brick or ground block that small Mario hit. Measured: the cell held `$23` for 14 frames.	Verified
	Every head hit that reaches `PlayerHeadCollision`, bump or break, sets `BlockBounceTimer` to 16, a frame timer. Until it is back at 0, the head check treats bricks and ? blocks as solid without the sound (smb1/head-solid), so no second block can be bumped or broken for 16 frames. Measured after five bumps: 16 on the hit frame, 0 sixteen frames later.	Verified
	During a bounce, and on the frame after a brick breaks, the block's cell holds `$23`, and every test of `PlayerBGCollision` takes its solid path for it: the head check's solid range starts at `$10` in group 0; the foot check's exceptions (climbable from `$24`, the axe `$C5`, hidden blocks `$5F` and `$60`) miss it, so it lands Mario or pushes him back; and the side check's exceptions (hidden blocks, climbable, coins `$C2` and `$C3`, jumpspring `$67` and `$68`, the pipe openings) miss it, so it ends in `StopPlayerMove`.	Code
	Breaking a brick (`BrickShatter`) sets Mario's vertical speed byte to −2, adds 50 points, spawns debris (smb1/brick-debris), and flags the cell, which holds `$23` meanwhile, to be cleared to 0. The clearing comes on the next frame's `BlockObjMT_Updater`, after that frame's `PlayerBGCollision`, so the next frame's head check still meets `$23` and sets the speed to 1: a break stops the jump one frame later, 1 or 2 px higher (computed), not passing through. Measured: 1 px higher, speed 1, and the cell 0 by the end of that frame, with a second brick stacked above never reached.	Verified
	`SpawnBrickChunks` makes the debris from two block objects at the block's place, the upper starting up at 6 px/frame and the lower, 8 px down, at 4 px/frame, both with horizontal speed `$F0`. `BlockObjectsCore` moves each under `ImposeGravityBlock` (`$50`/256 px/frame², fall cap 8) and draws them with `DrawBrickChunks`, which puts each object's two sprites at its own X and at the original X mirrored across it, plus 6, so four chunks fly apart.	Code
	Big Mario breaks a ground block he hits from below: the overworld's terrain metatile, `$54` (cracked rock), is in the hit range and not in `BrickQBlockMetatiles`, so the game treats it as a plain brick (smb1/bump-or-break). Measured with a `$54` block written 4 rows above World 1-1's floor: big Mario broke it, for 50 points, and small Mario bumped it, the block bouncing and coming back as `$54`.	Verified
	A brick with coins (`$58`, `$5D`) starts `BrickCoinTimer` at 11 on its first hit. Every bump gives a coin; while the timer runs the brick comes back as itself, and the first bump after it reaches 0 leaves a used block. It is an interval timer, counted down once every 21 frames, so the brick pays out for 11 such ticks, 211 to 231 frames (computed).	Code
The Legend of Zelda 1986	The NES Legend of Zelda booklet describes the bomb only as a weapon, a blast against enemies (p. 13); of the invisible doors in caves it says only "That's a secret".	Manual
Super Mario World 1990	A turn block (`$11E`) under the head point is hit from below like any functional block: it becomes bounce sprite 7, the turning turn block. That path doesn't read `Powerup`, and it breaks a block only when the block's `IntBlk_BounceSprite` entry is 7; the turn block's entry is 6 (its sprite number is 7), so a plain head hit never breaks a turn block, big or small. On the hit frame collision skips the head's downward move and only zeroes a rising speed.	Verified
	A block hit from below becomes a bounce sprite with an 8-frame timer and a vertical speed of `$C0` (−4 px/frame), and on its first frame, the hit frame, the block's cell becomes an invisible solid tile (`$152`) under it. Each frame the sprite moves by its speed's high nybble plus the carry of its low nybble into a fraction byte, then adds `$10` to the speed (a ? block) or `$13` (a turn block). Nothing clears that fraction, so a slot's leftover from its last bounce carries into the next.	Verified
	After a head hit, a turn block bounces through the hit frame and the five after it; on the sixth it snaps back to its cell as the always-turning tile (`$048`), which nothing collides with, so Mario passes through it. Its spin timer, `$FF` at the hit, runs down by one a frame, and 255 frames after the hit frame the cell becomes a turn block again.	Verified
Scorched Earth 1991	Scorched Earth 1.5's documentation sorts weapons that remove dirt ("Earth Destroying Weapons") from weapons that add it ("Earth Producing Weapons"): the first can clear a mountain in the way or the ground under the firer's own tank, and Liquid Dirt fills holes and smooths the terrain. Dirt left in the air normally falls; a Suspend Dirt setting, 0 by default, lets it hang.	Manual
Worms 1995	The Worms PC manual says the Bazooka "causes devastation to the landscape", and that the Blowtorch and the Drill let worms dig and burrow in it, the Blowtorch at six angles and the Drill straight down.	Manual
Worms 1995	Andy Davidson, who programmed Worms, told Time Extension it grew from the artillery games he had loved "since the 8-bit days", two tanks trading shots by angle and power, and that what interested him most was generating random landscapes; letting the tanks move was, he says, new for a genre that was "normally very static".	Interview
Red Faction 2001	Red Faction's lead designer, Alan Lawrance, told The Ringer that its Geo-Mod system takes a low-polygon shape that mimics an explosion and subtracts it from the world's geometry, floor or wall, leaving a hole; the team wanted to go beyond destroying a chair, a barrel, or a crate to destroying walls, the ground, or a structure.	Interview
	Alan Lawrance says that when Volition set out to make a game with destruction it looked at what was out there, "and there really wasn't anything".	Interview
	The Ringer's Ben Lindbergh sets Red Faction's Geo-Mod against the "more primitive environmental mayhem in 2D games like Dig Dug (1982), Rampage (1986), or Worms (1995)", and says Red Faction debuted in May 2001.	Interview
Dwarf Fortress 2006	In version 53.16, as the Dwarf Fortress Wiki describes it, the Designations menu marks tiles for dwarves to work: mining, wood cutting, plant gathering, stone detailing and other jobs, by rectangle, by painting, or for some designations as a box across z-levels. Each designation takes a priority from 1 (highest) to 7, and can be placed in blueprint mode, which dwarves don't undertake, to plan work ahead. A Mine designation needs a dwarf with the Mining labor.	Wiki
Dwarf Fortress 2006	The wiki, describing version 53.16, divides each layer of the three-dimensional map into a wall part and a floor part. Mining removes the wall and leaves the floor; channelling removes the floor too, opening the tile to the layer above, and turns a wall below into an upward ramp.	Wiki
Battlefield: Bad Company 2008	Alan Kertz, formerly of DICE, told The Ringer that when Battlefield: Bad Company was made "there were a few games doing destruction, but nobody was doing it on the multiplayer front", and that destruction has to leave craters, negative space, and rubble where players can still hide.	Interview
	DICE's general manager Karl-Magnus Troedsson told Game Developer that the studio's focus on destruction came out of discussions of how to differentiate itself, and recalled a Battlefield: Bad Company demo in which a tank kept "shooting holes in the houses", forcing a player on foot to move.	Interview
	Game Developer's 2012 feature says the Frostbite engine debuted in 2008 with Battlefield: Bad Company, which let players destroy parts of walls and parts of vehicles.	Interview
Infiniminer 2009	In Infiniminer v1.5 the pickaxe reaches 2 blocks along the player's view and removes dirt, ore, gold, and diamond blocks. It doesn't remove rock, lava, or built blocks. A gold or diamond block stays put while the player's loot is full; an ore block is dug even when the player's ore is full, and its ore is lost.	Code
Infiniminer 2009	In Infiniminer v1.5 the detonator, which the client offers only in the Sapper's kit, sets off every explosive that player placed. Each clears the 5 × 5 × 5 cube around it of rock, dirt, ore, solid and translucent blocks, ladders, shock and jump blocks, road, and lava, and sets off any explosive inside it. Gold, diamonds, banks, and beacons survive, and so does the map's outermost layer of blocks, which the blast skips.	Code
general	The Ringer reports that John Slagel, Red Faction's lead programmer, wrote a game as a teenager in the mid-1980s on an IBM PCjr in which bombs dropped from an ASCII-art plane left craters in the ground.	Interview

References

^ a b c dA player's shot that hits a shield erases itself, then ORs the 8 × 8 px ShotExploding pattern onto the screen around the point of impact; after the blow-up timer counts down from 16, EndOfBlowup erases that pattern with an inverted AND. The erase clears every pixel under the pattern's 38 set bits (computed), shield pixels included, and the first erase had already cleared the shield pixels under the shot itself, so the hole is the explosion's shape plus the shot's last 4 px.CodeComputer Archeology, Space Invaders

How we know

770; Shot blowing up because it left the playfield, hit a shield, or hit another bullet
77103D7: 35              DEC     (HL)                ; Decrement the timer
77203D8: CA 36 04        JP      Z,$0436             ; {code.EndOfBlowup} If done then
77303DB: 7E              LD      A,(HL)              ; Get timer value
77403DC: FE 0F           CP      $0F                 ; Starts at 10 ... first decrement brings us here
⋮
77903E3: CD 52 14        CALL    $1452               ; {code.EraseShifted} Erase the sprite
⋮
78203E8: 34              INC     (HL)                ; Change 1C90 to 1C91
⋮
79203F2: 36 08           LD      (HL),$08            ; 202B 8 bytes in size of sprite
79303F4: CD 30 04        CALL    $0430               ; {code.ReadPlyShot} Read player shot structure
79403F7: C3 00 14        JP      $1400               ; {code.DrawShiftedSprite} Draw sprite and out

content/Arcade/SpaceInvaders/Code.md lines 770–794 at 1adc2a7 · upstream ↗

836EndOfBlowup:
8370436: CD 30 04        CALL    $0430               ; {code.ReadPlyShot} Read the shot structure
8380439: CD 52 14        CALL    $1452               ; {code.EraseShifted} Erase the player's shot

content/Arcade/SpaceInvaders/Code.md lines 836–839 at 1adc2a7 · upstream ↗

2870EraseShifted:
2871; Erases a shifted sprite from screen (like for player's explosion)
⋮
2878145C: 2F              CPL                         ; Reverse it (erasing bits)
2879145D: A6              AND     (HL)                ; Erase the bits from the screen

content/Arcade/SpaceInvaders/Code.md lines 2870–2879 at 1adc2a7 · upstream ↗

4336ShotExploding:
4337; *..**..*
4338; ..****..
4339; .******.
4340; *.****..
4341; ..****.*
4342; .*****..
4343; ..*****.
4344; *..**..*           
43451C91: 99 3C 7E 3D BC 3E 7C 99

content/Arcade/SpaceInvaders/Code.md lines 4336–4345 at 1adc2a7 · upstream ↗

Checked against the evidence by its author, an AI model, 2026-10-22.

Checked by a second AI model, 2026-10-22.

#How it works

#Space Invaders (1978)

#Super Mario Bros. (1985)

#Other games

#Quirks

#History

Related

See also

Mentioned in

Lineage

Games

References

Sources

Code

Primary

Secondary