Andred Braybrook is a legendary computer game dev from the Commodore 64 age, and before and after. In addition to the classic C64 games Uridium and Paradroid, which perform feats of scrolling that machine are really not designed for, he went on to many several other games, including the excellent computer ports of Taito’s sequel to Bubble Bobble, Rainbow Islands.
(Although Braybrook mentions that Taito hadn’t told him about the three secret islands that can appear at the end, so they got left out. They didn’t know about them either!)
Image from Braybrook’s blog
He has a blog post that details many aspects of he and his co-workers’ process back then that is fascinating to anyone with knowledge of these platforms, and even someone who doesn’t. Thanks to @acb@mastodon.social for the link!
The Legend of Zelda: Breath of the Wild is a gigantic game, and where content proliferates, so too do bugs. Many of these bugs are highly entertaining (my favorite is the bullet time bounce), but there are some that are just head-scratching, leaving one to wonder why does this happen? That the occur pulls back the curtain on the many technically complex things a big game like BotW does behind the scenes to realize its world, for, every step of a process that a system must go through is one more opportunity for something to go wrong.
Youtuber Jasper has made a 35 minute video about why, if Link stands in a specific spot in BotW, inside the broken corner of a stone wall, the cel shading usually applied to his model goes away, and he appears with normal light shading. In the way of Youtubers, the explanation is contained within a 35-minute discursive video that goes into the history of game lighting, why some older 3D games have graphics that have aged well while others don’t, the basics of cel shading, and still other topics. Here is that video, embedded:
The whole video is pretty interesting, and if you have the time and interest you should watch the whole thing. However, in the event that this is all tl;dw, allow me to summarize.
Because Breath of the Wild is both a huge game and has a dynamic world, baking lighting in into textures would consume way too much storage and memory, so lighting has to be done dynamically.
As an optimization measure, the more complex steps of cel shading are deferred to later in each frame’s rendering. The main rendering is done, then the cel shading is applied afterward, when the visibility of the area has been determined, so this effort-expensive process is only done for visible pixels.
One of the deferred steps of rendering marks which of nine different kinds of material will be applied to each pixel. Terrain in BotW is not cel shaded, while characters link Link are, so they have different types of material that determine whether that shading is applied to them.
In the location where Link’s cel shading disappears, there is a decal applied to the crumbling bridge that erroneously extends over the corner, and overwrites Link’s character material type with the terrain material, causing the cel shading not to be applied to him.
Another Youtube video? Yeah I know. This one explains how gravity works in Super Mario Galaxy. It’s 29 minutes long. The basic gist is, there are eight kinds of invisible gravity field objects, based off of simple shapes, in the game, which are used in concert to create the various orientations that Mario switches to as he moves around: Parallel, Sphere, Cube, Disk, Torus, Cylinder, Wedge, Wire (basically an arbitrary path in space), and Cone, which is only used in two places.
An interesting fact from near the end of the video: gravity affects Mario’s shadow! Shadows point towards where Mario will fall, not according to how light strikes him, to give players a sense of where he is spatially in 3D space.
The Youtube channel Retro Game Mechanics has done a series of three videos on glitches in Super Mario Bros. One involves using the NES game Tennis, which has a certain property of its code that allows you to load all kinds of funky levels in SMB.
They’re all interesting, but the one that floats my particular boat is the third, which turns into a deep dive in the compressed manner that Super Mario Bros. stores its levels in ROM, and uses to draw them during play in real time.
I’ve been doing a lot of high-effort posts lately, even for things that should be fairly quick. Working to make this more sustainable, here’s a laid-back post that’s mostly just a Youtube video of a talk between the guys of Digital Foundry and Randy Linden, coder of the SNES port of DOOM, which uses the SuperFX chip to make the hardware push polygons at a rate that, while not stellar by PCs-of-the-time standards, at least not abysmal.
Let’s run down the differences of hardware:
PC running MS-DOS: targets VGA monitors, displays all its pixels in software, but makes up for it with a minimum requirement of a 386 running (if memory holds up over nearly 30 years) at 33 mHz.
SNES: Its processor is a much slower workalike of the 65C816, a 16-bit version of the 6502, running at 3.58 mHz. While it makes up for its slower clock speed with a simpler design, meaning instructions complete generally in fewer cycles, it’s hard to make up for that 10-fold difference in speed.
Their use of specialized graphics hardware was an important advantage, at the time, of consoles over personal computer hardware. Even many standard home microcomputers, like the Commodore 64 and Atari 800, had dedicated graphics hardware that helped games run better than what most PCs could do. Even when VGA came out, the standard had no hardware-level support for scrolling or sprites.
Consider what it takes to scroll a screen without hardware support: something in the system has to be able to move every pixel from one spot on-screen to another. The NES pulls this task off by having a bank of memory that its PPU can be pointed within, meaning the memory could stay in the same place, and the graphics chip would just work from a different region within it. Sadly, this technique is not amenable to 3D graphics, which usually do require every pixel on the screen to be recalculated every frame, either in software or hardware.
The SNES is known for having a rather slow chip for its time, but more demanding games tended to make up for it with co-processor chips included on the cartridges. The most well-known of these are the DSP-1, which functioned as a math co-processor; the SA-1, which was basically a second 65C816 running at around triple the speed and with a few added features; and the SuperFX, which ran at about the SA-1’s clock speed but functioned as a graphics accelerator. (The later SuperFX 2 ran at twice that speed.)
These were far from the only add-on chips included on Super Famicom and SNES carts. Since the SNES had a much larger address space than the NES’s 6502-clone, the need for mapper chips was much less, but these co-processors were used in a number of more notable games to help it make framerate goals.
Hm. Well, I tried making it a laid-back kind of post. Ah well, back to playing Live-A-Live.
When you start using emulators, it won’t be long before you’re brought up against the choice of which scalers to use, a bewildering collection of options with names like Nearest Neighbor, AdvMAME3x, and RotSprite.
Resizing pixel images in an intelligent way is a difficult problem for many reasons. Most techniques intended for use on photographs won’t apply, since they’ll produce unacceptably blurry results when applied to extremely low resolution art. Pixel art is designed so that every dot matters, and adding new pixels carelessly can cause problems, such as Mario flipping us the bird in the right-hand image below:
Mario vs MMarrioo:A possible result of bad upscaling.
Additionally, being done frequently in real-time emulation, scaling algorithms must be fast. Yet the fastest solution, called Nearest Neighbor, produces very blocky results, and also only really works well if images are scaled up to an integer multiple of the original in X and Y dimensions.
A good backgrounder of various issues is available from an old blog post here, but there’s been some interesting advancements in the field since then. RotSprite is a good contemporary solution that also can rotate pixel art images well.
A raycaster engine is a simple 3D engine that just draws lines from the player’s position to the nearest terrain wall for each horizontal pixel on the screen. It was what was used in one of the foundational 3D action games, id Software’s Wolfenstein 3D.
For those with a coding bent (the word bent seems so suitable when it comes to people who enjoy programming), Youtube account 3D sage demonstrates how to implement a raycaster in a series of three videos. The first one is embedded below:
Here are links to the whole series: Part 1 (17 minutes), Part 2 (14 minutes), and Part 3 (22 minutes)
Later he did another series on implementing the kind of engine that’s in DOOM, but we’ll look at that at a later date.
This is one going out to all you developers out there, either current or aspiring.
It’s amazing to me how fussed, nay, obsessed-over the 16-bit Sonic the Hedgehog games are even to this day. There are a lot of good things about them, and arguably the best is their platforming engines, which are among the best in the field. They take advantage of the processing power of the Genesis/Mega Drive, fueled by a Motorola 68000 processor, the same processor as the classic Apple Macintosh, clocked only slightly slower. This was basis of Sega’s infamous “blast processing” slogan at the time, touting how much faster the Genesis was than the Super Nintendo Entertainment System. This was somewhat unfair, as SNES carts often came with supplemental chips in them that acted like co-processors, and was of a completely different architecture as well with different characteristics, but it did make the Sonic engine possible. A lot of the credit also goes to Sonic programmer Yuji Naka, who is legendary in game coding circles for a very good reason.
If this is the kind of discussion that makes your heart race, we’re glad to have you reading Set Side B! If it’s not, that’s okay. I’m a bit stymied myself, even though I love dives like this. (All images in this post from Sonic Retro.)
The result of the Genesis’s power and Naka’s expertise was a game engine with, yes, raw speed, but also a lot of nuance. If you jump and land on an enemy or monitor, you can control the height of your rebound, no matter how fast you were going when you hit it. If you jump while on a slope, you don’t jump straight up but away from it, which takes some getting used to at first but can be taken advantage of. There’s lots of fun little cases like these, and figuring them out, and their implications, is the source of a lot of the joy of playing Sonic the Hedgehog for the first time.
Those two places where the slope only intrudes slightly into Sonic’s ground tile are what get me.
I’d even argue, without the solid engine, and great level design taking advantage of it, all of Sega of America’s marketing efforts, which formed the foundation of the media juggernaut that Sonic has become today, with several cartoon series and comic books, and two successful movies and a third one in the works, would have been for naught.
Judging by the later 2D adventures, the nuances of Sonic the Hedgehog’s engine are difficult to grasp without a good amount of effort. It is likely that Sega themselves don’t have the institutional memory to understand how they worked, which is why they went to Christian “The Taxman” Whitehead, and others from the fan game community, to make Sonic Mania, which has a faithful recreation of the original games’ physics.
Why has no one made a Sonic half-pipe trick skateboarding game?
Bringing it back around, the obsession of the Sonic fan community has produced a number of disassembles of the game’s code, which have served as the basis for a wide array of romhacks of rather shocking levels of quality. I wrote about many of those in the Someone Set Up Us The Rom ebooks (ahem).
They also served as the basis for the subject of this post, the physics descriptions at Sonic Retro. Here is basically all you need to make a Sonic-style platformer. Synthesizing this and putting it into practice is a formidable task on its own, but it’s a doable one, and you don’t have to read source code (other than your own) to do it. To those who attempt this task, we salute you! And let us know how it goes!
It’s hard to believe that Legend of Zelda fangame construction system Zelda Classic and ZQuest is 23 years old. Many such systems have fallen by the wayside during that time, but Zelda Classic continues on. Its first versions were made for DOS, but it continues to see improvements to this day.
ZQuest has this weird interface where they rolled their own controls for everything. The dev system seems to be rendered in Allegro.
Zelda Classic and ZQuest are made specifically to make overhead view action-adventures in the Legend of Zelda style, to the extent that it has graphic sets taken directly from the games and many items that work like their console counterparts.
It even simulates many of the quirks from the various Zelda series titles. And yet, it doesn’t require you to abide by them. Pretty much every technical or creative limitation of the 2D Zelda series has an option to disable it if you like, but if for some reason you consider it intrinsic to the experience you can keep it too.
The graphics can be completely changed out. With it, you can make a game that doesn’t look anything like a Zelda title, which I suspect is why it’s been able to survive 23 years in a legal landscape overseen by a Nintendo increasingly draconian in its approach to guarding its intellectual property. Still, it’s pretty heavily aimed at making Zelda fangames, right down to having pages and pages of checkboxes for every known quirk of Zelda engine behavior.
Look at that gloriously pedantic list of quirks! The ZQuest developers are awesome.
While it does offer a scripting facility (which it’s difficult to find documentation for), ZQuest is mostly a construction set type of program. You place tiles and enemies, lay out overworlds and dungeons, decide what items to include, and go. The program itself has little in the way of documentation but the site has a tutorial that should help one get started. I strongly suggest, if you are interested in creating for this system, that you read it.
A lot of the gaming web has been fawning over Kirby and Smash Bros. creator Masahiro Sakurai’s design videos. I haven’t had the chance to look at them yet, but they look interesting at least. They’ve been coming out at a good clip, like one every two days.
Sakurai’s star is so high right now, that it’s worth noting that (going by memory) he left Nintendo with a bit of a cloud over his head, after Kirby Air Ride was seen as something of a failure. Nowadays KAR (nice acronym!) is seen as an underrated classic, and I have put many hours into its City Trial mode, which is terrific, a tiny open-world high-speed racing/party game. More people should have the chance to play it; it is unique, which is something I can’t say about many other games. While the 3DS version of Smash Bros. has a mode inspired by it, in versus mode human players cannot interact with each other during the exploratory portion of the game, which harms it somewhat.
At the height of his abilities, Sakurai can make really interesting and new kinds of games, like Smash Bros. was, and like Kirby Air Ride and (the sadly neglected these days) Meteos are. It’s a shame that Smash is so popular, one of Nintendo’s biggest tentpoles, enough to crowd out his other work. I’m really interested to see what the next crazy idea he comes up with will be!
Another interesting game-related video he’s made is about the beloved old pinball game that was included with Windows during the XP days, but vanished with Vista. The game’s exclusion was the subject of a blog post by former Microsoft developer Raymond Chen, who mentioned that he had trouble getting the game to work correctly under 64-bit Windows. The ball kept clipping through objects, and sometimes falling through the plunger and out of the table. NCommander’s examination indicates that the problem was probably related to floating point precision as Chen had said, but that the cause was probably more complicated than that, and may have had to do with issues getting the game to run correctly on Intel’s ill-fated Itanium architecture, their first attempt at a 64-bit processor.
NCommander’s explorations were made possible by the discovery that, although there was no way to get the installer to offer it, the 3D Pinball game files are on the CD for the various editions of XP for Itanium. For more information, I refer you to the video, embedded above.
Notably, Chen has responded to NCommander’s video with more details about the game’s removal, which make the story even more interesting, bringing in Alpha AXP, a second obscure 64-bit architecture that could run Windows XP.
It should be said that all of this is much more technical than the usual post here. Please don’t freak out too badly if this makes little or no sense to you. We’ll have something marginally more comprehensible for you tomorrow.
Tiled is a popular open-source tool for tilemap construction
Popular and prolific game asset creator Kenney has a page up at Github that links to some of his favorite tools for manipulating pixel art, such as creating sprite sheets and extracting images out of them. It’s got a lot of useful info! If you have an interest in this style of art, especially making games with it, these programs are worth having in your toolbox.
