Every Graphics At Once: Nintendo's Popeye

I’ve made some modern games in retro style, and one thing people will always tell you is, make sure your pixels are the same size. When your base resolution is 1080p, it’s pretty easy to accidentally include sprites scaled differently or at different resolutions; and most retro systems like the NES and Genesis only had one possible pixel size. But all rules are made to be broken– Nintendo brought out a system with three pixel sizes. Powered by spinach.

A brief history of graphics

The very first arcade game with a CPU was Midway’s 1975 port of Gun Fight. (Oddly, the Taito original was a discrete-logic game) It used a simple 260x224 resolution, with each bit in video ram corresponding with a pixel on screen. This is often called a framebuffer.

That was fine for what it was, but suffered from a major flaw: it used a lot of RAM, in an era where RAM was very expensive. 7.1kiB was barely achievable at arcade prices– notice that the 1983 Famicom would have less than that in total, whereas for the Midway 8080 (also used by the megahit Space Invaders) that was only the video RAM, and additional memory was needed for the game state.

And remember, that’s all one bit per pixel, no room for color. Maybe eventually RAM prices would be cheap enough to have a true framebuffer system, but the realities of 1970’s finances would require other solutions. (Or extremely low resolutions, like the Channel F)

The oldest form of digital graphics may very well be “text mode”, used in early screen terminals. The screen is divided into a grid of identically-sized rectangles, each of which has what’s usually a monochrome image. This dramatically reduces the amount of RAM needed; in the IBM PC text mode, a fairly typical example, each character can have different foreground and background colors. Games like ZZT can actually be very colorful.

Now, it’s interesting that this is called “text mode”, when in 2023, most of the time we read text on the computer, it’s in a variable-width font. Text mode, remember, is fixed-width; on the other hand, as the PC example shows, the tiles can be anything, not just letters. So this is actually very useful for video games.

In video games, this is often called a tilemap rather than text mode, and the tiles can often be multiple colors. In arcade games, or in the Nintendo Entertainment System, they’re often stored in ROMs, just like a text-only graphics card might have its font in ROM.

This is a screenshot from the development of Aspect Star “N”. Everything you see on this screen is a tile; it’s bright and colorful, and higher-resolution than Midway’s 1977 system (which used more RAM). It’s also random, but that’s just because this happens to be a screenshot of a glitch.

The limitation of tilemaps is that each tile has to be moved as a whole. This is fine in some cases, like the enemies in the NES port of Gauntlet’s, but if you play this game it’s very clear that they’re fixed to a grid. (Note that the NES, like many systems, features the ability to scroll the tilemap, so the corner of the screen doesn’t necessarily correspond to the corner of a tile)

But in Gauntlet you’re not fixed to a grid. And that’s because the NES doesn’t just have a tilemap– it also has sprites. Sprites bridge the gap between tile mode and framebuffers– they are a set of fixed graphics that can be positioned freely on screen, subject to various system-dependent hardware limitations. In Aspect Star “N”, all of the enemies, the player, the bullets, and even some of the bugs are all sprites.

The combination of a tilemap with sprites in the arcades is usually attributed to Namco’s 1979 Galaxian, and in home systems with the TI TMS9918, which also debuted in the 1979 TI-99/4. Hardware like this quickly became the standard for 2D video games of the 1980’s and beyond because of its flexibility. Today’s game is no exception. Except when it is.

Nintendo’s Popeye

Sometimes, media from one country is very popular in another country, even moreso than its country of origin. That’s the case with King Features Syndicate’s comic character Popeye. As an American, I mostly remember it as an old children’s cartoon with an exceedingly catchy theme song. It doesn’t seem to be as popular today even as much as when I was a kid, I’m not sure if young people would recognize him at all. Even in my generation, I think a lot of people would be surprised to find the Sunday comic is still ongoing.

In Japan, on the other hand, Popeye was so popular that he lent his name to a pop magazine and his franchise is one of the highest-grossing pachinko machines. This is all on-going too, but it was also true– or even more so– in the early 1980’s.

Why did Popeye scratch the Japanese psyche? Was it a product of the post-war occupation of the country by the United States? Actually, it seems to predate the war– perhaps the everyman sailor just scratched the heart of the island nation regardless. In any case, Popeye the Sailor Man: he yam what he yam, he’s big in Japan, and Nintendo wanted his license. For Game & Watch, and arcade.

Now, you might notice something about the screenshot I posted: It looks great. No way that’s a 240p image, right? Well, right. Popeye runs on a normal 15kHz arcade monitor, though. So how are they doing it?

Oh right, interlacing. But still, this resolution in 1982 is nothing to sneeze at. Let’s see what tradeoffs they made.

Three levels

The title screen is one thing. But here’s the first level of Popeye. A close look at this screen should start to show how this game works.

Tilemap

The very top level is the tilemap. MAME happens to have a nice debug mode for this, since tilemaps are so common. In Popeye, though, the tilemap is pretty sparse, used for some scenery and the HUD mostly. Like any tilemap of the era, it’s made up of 8x8 tiles stored in ROM.

By the way, in case you were wondering, here’s what the title screen tilemap looks like.

What’s interesting here is that the tilemap is not actually interlaced. Well, it is to a degree, since the whole image will still be shifted, but it has no difference between frames. This is the same style and resolution of tilemap you’d see in, say, Donkey Kong. It might as well be 240p.

Sprite

Up next is the sprite layer. As you can guess, this is where we have the nice, detailed, interlacing. And as far as I can tell, the sprite layer is always drawn behind the tilemap layer. As a fixed tilemap always on top, this basically means the Popeye hardware is the same thing as the Neo Geo.

While Popeye’s sprites are higher resolution than those in Donkey Kong or Galaxian, they’re actually more limited. For one thing, they have no clipping. Transparent pixels aren’t transparent to other sprites, only to the background.

Interestingly, when the Sea Hag phases in and out of existence, the sprite phases in every other line. Were the developers inspired by the interlaced nature of the graphics?

The background

The background is one of the more interesting elements, as I don’t think this sort of thing is seen very often in arcade games. Here’s an attempt I made to recreate the above scene, with only the background.

The background layer is a 128x128 grid that is freely addressable in RAM. Looking at the MAME source, 4 bits are attributed to each pixel on screen, which would imply 8kiB of RAM. This is a framebuffer! And the flexibility of the framebuffer approach allows for some very nice variety between levels.

The tradeoff, though, is pretty clear: a 128x128 grid expanded to the full resolution of the screen means that the pixels are huge. This is the sort of thing I notice even playing the game in the arcade, or on my little trinitron PVM.

And there we have it. Popeye does it all, a tilemap, sprites, and a framebuffer; plus, it does each at a different resolution with a different pixel size. How often do you see that?

Do you even have a board

Trinitron image aside, one other thing you might notice about all those images: they’re screenshots, taken in MAME. Usually, I like to show off real hardware on this blog. And I do have the real thing:

Popeye is a pretty large board, consisting of two separate attached circuit boards. It uses the same pinout as Donkey Kong Jr., and so I can use the same adapter, which among other things, needs to reverse the video signals and amplify the audio, making it a bit complicated.

That chip under the giant grey heatsink is an AY-3-8910, by the way. I’m not sure why the AY-3 needed such a giant heatsink, as I have pretty much never seen it like that. It’s the same soundchip used in the Apple ][ Mockingboard and in MSX computers.

The second circuitboard is labeled TPP2-01-VIDEO, so I assume that this is the video circuitry. Perhaps it’d be worth trying to pull out.

Fancy video signals

So, why don’t I have any capture? Well, the Framemeister, my usual old reliable for video capture, doesn’t lock onto its signal at all.

The GBS Control does a little better, but it still struggles a lot. Much like I do while playing the game.

Actually, looking closer at this, it’s hard to tell if the errors are coming from the GBS Control, or from the VGA to HDMI adapter. In either case, I can’t get a good capture though. Let’s try the RetroTINK-5X, taking it from its living room location where it still lives plugged into the LaserActive.

The RetroTINK-5X still had a rough time; its deinterlacer was unable to deal with it, and I got constant motion and loss of sync throughout. Not exactly playable, but I possibly could’ve hacked together some screenshots from this.

What’s interesting is that the picture didn’t load at all if I wasn’t in the RetroTINK-5X’s “Triple Buffer” mode. Which goes well with the stats we see: 61.40 Hz is, by video standards, well out of the 59.94 Hz we’d expect. Let’s take a similar screenshot of a more well-behaved 480i signal, the Atomiswave.

You can see that this is a nice 59.94Hz. Remember when I looked at the RetroUSB AVS? That ran at a clean 59.94Hz, but the NES ran a slightly fast 60.10Hz. A 0.2% speed increase that nevertheless causes some issues. Popeye is running 2.5% fast, and it looks like it’s also not following the spec for the number of horizontal lines. So that’s something digital upscalers aren’t equipped to deal with.

I’d like to show you some nice oscilloscope plots here, but I don’t actually have a good enough oscilloscope to measure horizontal sync. I can at least show the differing vertical sync rates, though. Notice how quickly the two get out of sync with each other.

Who made Popeye

When I talked about the Sega Zaxxon hardware, I noted that initially, Nintendo didn’t actually design their own arcade hardware. 1981’s Donkey Kong was made under contract by Ikegami Tsushinki, with Nintendo’s staff handling game design and Ikegami providing the programmers and boards.

Nintendo decided to manufacture their own boards from Ikegami’s design for later Donkey Kong releases, and cloned it wholesale for 1982’s sequel, Donkey Kong Jr. Ikegami didn’t take this well, and that’s likely one of the reasons why we ended up with Sega’s isometric Congo Bongo, another brainchild of Ikegami.

In any case, Nintendo from then on started developing their own arcade hardware; early 1984’s Punch-Out!! was, as far as I know, an in-house affair. (Or at least, they got a more ironclad contract than with Ikegami) It didn’t run in interlaced mode, but did have two screens and huge sprites with scaling, so their hardware team were no slouches.

UPDATE 2/27/2023: RachelRetro let me know that in fact, the arcade version of Punch-Out!! seems to use interlaced mode. The current version of MAME does not have this implemented, but there is a bug report. The plot thickens?

Popeye came out in November 1982, four months after Donkey Kong Jr., so you might assume that it was a starter work for Nintendo’s new hardware team. But there’s a problem. A problem by the name of Mr. You.

At the same time Donkey Kong was in development, Nintendo released another game with featuring a villainous gorilla: Sky Skipper. This game flopped incredibly hard on release testing. Nintendo wasn’t the hit-after-hit studio we know and love today.

Now, I don’t actually know if Ikegami Tsushinki did Sky Skipper. As we saw with Donkey Kong and Zaxxon, they often included little clues in their ROMs to show they made it, and I couldn’t find any text or images in Sky Skipper of that sort. Wikipedia credits them with it, based off of a book I don’t have. But one thing’s for sure, the hardware in Popeye is a direct derivative of the hardware used in Sky Skipper. In fact, it makes a lot more sense here.

The low resolution backgrounds have hardware scrolling capability because they are, in fact, scrolling. They didn’t just develop that for Brutus/Bluto (he has two names, for Complex Historical Reasons) hitting the side of the screen. And you can see all three layers.

I would argue Popeye looks a lot better, though, with the clever use of tiles to cover up the pixelatedness of the background. Of course, it’s easier to do tricks like that on a single-screen game that rarely scrolls– remember, the scrolling only applies to the background layer.

Toot toot

A long blog post! And to be honest, I didn’t even say anything about the gameplay. It’s an interesting concept, a hero who can’t jump, and one major enemy who very much can jump, and breaks the rules of platform games. Honestly, though, it’s not as fun as Donkey Kong– had King Features Syndicate been willing to sign the license agreement earlier, they would’ve got the better game. But it’s still fun, and seems to be a staple of retro game arcades even today– despite being hard to upscale on an LCD.

In any case, see you next time– and until then, may all your tilemaps be full of stars!