Arcade Games#

8bitworkshop supports programming classic arcade game hardware platforms.

VIC Dual#




Blockade, Carnival, Head On


Z80 @ 1.934 MHz, 8 KB RAM

The VIC Dual’s video generator has more in common with the dumb terminals of the day than later video games. The video generator can display a 32x28 grid of cells — or 28x32, if the monitor was rotated 90 degrees. Each cell is cell taken from one of 256 8x8 pixel bitmaps, also defined in RAM. Early boards only supported monochrome graphics, but later boards could output 8 different colors.

The layout of the cell grid is simple — rows and columns of bytes, each byte telling the video generator which of the 256 characters to use.

Midway 8080#




Gun Fight, Space Invaders

The Midway 8080 architecture generates video from a black-and-white frame buffer, using a whopping 7KB of RAM.

The video frame has 256 horizontal by 224 vertical pixels, and also can be rotated 90 degrees, as it is in Space Invaders. Each byte corresponds to eight pixels – for each bit, 1 means a lit pixel, 0 means dark. There are 32 bytes per scanline, thus 32 * 8 = 256 pixels across (or upwards if the screen is rotated.)





Galaxian, Scramble, Crazy Kong

The Galaxian hardware pushed the limit of video game designs in 1979. At its core is a Z80 CPU at 3.072 MHz. The graphics system featured color RGB graphics and multicolor hardware sprites overlapping a tiled background.

Galaxian uses a 32x28 tilemap like the VIC Dual hardware, but each column can be assigned separate color attributes. Also, individual columns can be scrolled left and right, or up and down if the monitor is in landscape orientation.

Galaxian’s sprites are 16x16 bitmaps with three colors (plus one transparent color) that can be positioned anywhere on the screen. They overlap the background tilemap and also each other. There can be up to eight sprites on a given scanline.

There are also eight ``bullets’’ that can be separately positioned and show up on the screen as short vertical lines, or single pixels.

Vector Games#




Space Wars, Asteroids, Lunar Lander, Tempest, Star Wars

The history of vector games started with the PDP-1 computer and a game called Spacewar! developed in 1962 by Steve Russell at MIT. Another MIT student, Larry Rosenthal, recreated the game with a homemade CPU and a line-drawing vector display CRT. Cinematronics purchased the technology and released the game as Space Wars in 1978.

Atari developed their own vector technology. In 1979 they released a vector game called Lunar Lander, inspired by an older DEC demo used to promote its vector graphics terminals. Their hit title Asteroids was inspired by Spacewar!.

The vector monitors in early black-and-white Atari games were controlled by a custom circuit called a Digital Vector Generator (DVG). This circuit is a rudimentary processor which takes instructions from memory and converts them into signals that draw lines on the vector display.

The CPU fills a special area of RAM with DVG instructions and tells the DVG to start drawing. When the DVG is done, it signals to the CPU that it is ready for the next set of instructions.

The Analog Vector Generator (AVG) replaced the DVG in later color games, adding color support and additional scaling effects.

Williams Hardware#




Space Wars, Asteroids, Lunar Lander, Tempest, Star Wars

The Williams hardware team designed an elegant architecture that left most of the power (and responsibility) in the software developers’ hands. The frame buffer is 304 by 256 pixels with 4 bits (16 colors) per pixel, taking up 36 KB of memory — in 1980, that was a lot. Each of the 16 colors can be chosen from a 256-color RGB palette.

Lacking any sort of hardware acceleration, the Defender developers achieved its lightning speed by using pixel-sparse visuals and clever tricks. Later games featured a powerful 4 MHz coprocessor that could draw sprites and rectangles to the frame buffer at astounding speeds for the time — moving almost 1 MB/sec of data. This gave games like Robotron: 2084 their massive sprite count. Called “the Special Chips,” they worked as a pair, each chip handling one pixel at a time.