# Super 8 by Innovation - Review

I recently purchased a rare accessory for my SNES that allows me to play NES and Famicom games on my SNES called the Super 8, designed by Innovation in 1993. One can also play SNES and Super Famicom games using the pass-through slot. The system uses a NOAC for playing NES and Famicom games in a similar fashion to how the Super Gameboy used Gameboy hardware for playing Gameboy games on the SNES. Since I have an NES, it's more of a novelty item for being able to use only one console to play each set of NES and SNES games. It's compatible with most NES and Famicom games out of the box including Castlevania III with the MMC5 mapper and Akumajou Densetsu, the Japanese version of Castlevania III, with the VRC6 mapper and enhanced audio. Some games do not work due to the system being a NOAC and not original NES hardware. The NES PowerPak by RetroZone does not work on the Super 8 for some reason, but perhaps this will be fixed in a later firmware update for the PowerPak.

Once my unit arrives, I will begin compiling a list of compatible games and how it compares to the NES.

Known issues with fixes:

- The Super 8 does not include native support for SNES games that use co-processors, but this can be fixed by adding a few solder points on the mainboard - I will update this later with the exact guide on how to fix
- The Super 8 suffers from the same jailbars issue that the top loading NES and some Famiclones experience - this can be fixed by soldering a 470micro farad cpacitor - I will update this post with where to solder later

# My NES and SNES game collection

It's been a while since I've posted a new blog post. I've been fairly busy with life and work lately. Over the past couple of weeks, I've been expanding my NES and SNES game library. I plan to collect several original titles that I enjoyed playing as a kid. Some of the games that I recently acquired for the NES are:

- Donkey Kong Classics
- Tengen's Pacman
- Tetris
- Othello
- Mario Bros. Arcade Classics
- Castlevania I
- Castlevania II
- Castlevania III
- Duck Tales
- Dr. Mario
- Caesar's Palace
- The Bugs Bunny Birthday Blowout
- Tengen's Road Runner
- The Bugs Bunny Crazy Castle

- Super Mario Bros. / Duck Hunt
- Super Mario Bros. 2
- Super Mario Bros. 3
- Home Alone
- The Legend of Zelda

- Sim City
- Donkey Kong Country 3
- Buster Busts Loose
- Kirby's Avalanche
- Super Mario World 2: Yoshi's Island

- Super Mario Kart
- Super Mario All Stars + World
- Super Off Road the Baja
- Jurassic Park
- Donkey Kong Country
- Donkey Kong Country 2
- Final Fantasy Mystic Quest
- The Legend of Zelda: A Link to the Past
- Chrono Trigger
- Starfox
- Mario Paint
- Final Fantasy II
- Final Fantasy III
- Super Battletank: War in the Gulf
- Super Caesar's Palace
- Super Mario RPG
- SNES PowerPak
- Super Gameboy
- Super Metroid

# SNES SDK

Over the past few days, I have been playing around with the SNES SDK that compiles C code to SNES ROMs for running in emulators or on real hardware. The SDK supports floating point emulation, 16-bit integers, controller input, and a basic graphics system. There is no sound support in the SDK for the SPC of the SNES (yet). Libraries can be added to the SDK pretty easily by writing C code and compiling to assembly to be linked with other programs.

In playing with the SNES SDK, I noticed that in math.h, a lot of the ANSI C math functions were left out due to hardware limitations of the SNES. However, without much effort, I was able to create working functions for the six basic trig functions and a square root function.

In mathematics, sine and cosine can be approximated by Taylor polynomial expansions. This makes it easy to implement functions in C to compute the sine and cosine of a value to a certain degree of precision. The following is the Taylor expansion functions for sine and cosine:

// taylor series expansion of the sin function float sin(float x) { return x - (mult(x, 3) / fact(3)) + (mult(x, 5) / fact(5)) - (mult(x, 7) / fact(7))+ (mult(x, 9) / fact(9)) - (mult(x, 11) / fact(11)) + (mult(x, 13) / fact(13)); } // taylor series expansion of the cos function float cos(float x) { return 1 - (mult(x, 2) / fact(2)) + (mult(x, 4) / fact(4)) - (mult(x, 6) / fact(6)) + (mult(x, 8) / fact(8)) - (mult(x, 10) / fact(10)) + (mult(x, 12) / fact(12)); }

I had to create helper functions for x^n and x! (x factorial) since those aren't built into the compiler. The function, mult(x, n), raises x to the power n. The function, fact(x), computes the factorial of x. There is a pow(x, n) function implemented in the SDK, but it doesn't produce as accurate of results as my mult(x, n) function. The result can be seen when running pow(2, 12) versus mult(2, 12). The pow function returns 4095 while mult returns 4096 (the correct result).

The other trig functions were built on the sin and cos functions. There is a Taylor expansion for tan(x), but I decided to go with sin(x)/cos(x) since I couldn't properly expand tan(x) for enough accuracy. Below is the rest of the trig functions:

float tan(float x) { return sin(x) / cos(x); } float sec(float x) { return 1 / cos(x); } float csc(float x) { return 1 / sin(x); } float cot(float x) { return 1 / tan(x); }

I understand the practicality of computing trig values on the SNES might not be huge for everyday use. However, this was more of a "Can I do this?" type of exercise. Games like Starfox for the SNES may have used trig calculations on the Super FX co-processor, but I doubt many games needed cosine or sine functions calculated on the main CPU. Perhaps game demos with oscillating text used sine or cosine as a function of time.

The square root function is based on Newton's method. I found the code for this method here: http://www.codeproject.com/Articles/69941/Best-Square-Root-Method-Algorithm-Function-Precisi

// babylonian method for square roots float sqrt(int n) { // double a = (eventually the main method will plug values into a) float a = (float) n; float x = 1; int i; // For loop to get the square root value of the entered number. for( i = 0; i < n; i++) { x = 0.5 * ( x+a / x ); } return x; } double newton_sqrt(double n) { double x = 0.0; double xn = 0.0; int iters = 0; int i; for (i = 0; i <= (int)n; ++i) { double val = i*i-n; if (val == 0.0) return i; if (val > 0.0) { xn = (i+(i-1))/2.0; break; } } while (!(iters++ >= 100 || x == xn)) { x = xn; xn = x - (x * x - n) / (2 * x); } return xn; }

There are tons of different ways to compute an approximation to the square root, but I was more concerned with precision vs. speed.

Here's the code I used including the SNES SDK:

Here is where I found the SNES SDK Win32 binary:

http://forums.nesdev.com/viewtopic.php?f=12&t=6253

You will need Windows XP or higher for the SDK. The source for the SDK may be found here: http://code.google.com/p/snes-sdk/source/checkout

Here's a screenshot of my test program running in ZSNESW: