I fell down the rabbit hole making a homebrew SNES game about a days previously, and since I could perhaps not gain many simply resources, I figured I could write one thing of a tutorial.

There are numerous resources obtainable for writing NES games, but procedure fewer for SNES games — I deem there are about a reasons for this. First, the NES is great extra gleaming than the SNES — this is factual of both the NES hardware itself, but furthermore of the 6502 chip as against the 65816 frail in the SNES. Many people have a nearly spiritual connection to the 6502, whereas the 65816 is fairly clearly a backwards-fancy minded hack of an structure. Secondly, the NES is nostalgic for folks who seemingly realized to program by writing meeting, whereas other folks for whom the SNES holds nostalgia are potentially around a decade older, and have been extra at risk of have realized high-level languages, and thus to be nervous off by the prospect of writing meeting. I deem this apprehension is misplaced — writing meeting will not be always great more difficult than writing high-level code, it is appropriate assorted, and requires rather extra attention to component — but I believe it is part of the cause for an absence of SNES sort resources.

This tutorial is geared towards other folks who:

• Are attempting to assemble a game entirely from scratch
• Are attempting to know how every little thing works below the hood
• Are already satisfied programming and the utilization of the repeat line

Namely, I’m not going to be explaining 65816 meeting, though I will link to some resources for it. My plan is to give a high-level overview of what you wish to enact in convey to catch varied issues working, with rather little bit of properly-written example code and residing proof applications for each and every step.

I’m furthermore not going to level aspects of the SNES which have already been outlined 1,000,000 assorted conditions on the ranking. For an outline of the aspects of the SNES, I counsel the Tremendous NES Parts series of videos from Retro Sport Mechanics Defined. First and predominant of each and every put up, I’m going to jot down about what you’re going to must always know to salvage it, and link to the linked videos or documents. This series of posts could also be understanding to be one in every of these accomplice series to these videos, in convey to bridge the hole from thought to observe with shrimp, concrete, working examples.

The example code will seemingly be saved brutally straightforward, to the level of perchance even being rather sinful. That is to support you to assemble your own copy of it, edit it, and assemble it your own. I counsel copying the code from part one, and then applying the modifications in each and every unusual part manually, so that you have to presumably be also ultimate issues up and gallop issues around as you gallop. In each and every little thing, I’m going to link both to your whole code and a diff from the previous part.

Setup

With that out of the vogue, let’s catch began. Step one is placing in a pair instruments — we will need:

• A 65816 assembler and linker. I could presumably be the utilization of ca65 and ld65, which near with cc65.
• A SNES emulator. I highly counsel Mesen-S. It be sadly not being developed, but it and not utilizing a doubt works properly, and it has potentially the most productive debugger I’ve stumbled on. I furthermore check my code on bsnes and zsnes every so continually — it’s essential to aloof guarantee that your code works at the least on Mesen-S (which does issues fancy randomize uninitialized memory) and bsnes (which is broadly regarded as potentially the most simply emulator).

Scoot forward and set up both of these, and load up Mesen-S with a in reality estimable ROM file that I’m sure you have to even have gotten lying around. Whereas you have to additionally very properly be there, protect a peek at the debugging instruments — try single stepping in the debugger, taking a peek at the memory, and taking a peek at the persona living / tile living / sprite viewers. These are extraordinarily functional instruments, and it is simply to have some familiarity with them earlier than issues birth going mistaken. When you happen to develop not know 65816 meeting, it is potentially functional to single-step via about a dozen instructions with a 6502 / 65816 reference birth, predicting what each and every instruction will enact and checking your work every time. It be lovely to not solely understand every little thing, but it and not utilizing a doubt’s simply to catch a in actuality feel for issues!

Sources

That is in actuality all you need! Sooner than leaping into writing some code, here are some resources that I’ve stumbled on functional:

• fullsnes — SNES hardware specs — A mountainous treasured handy resource for taking a peek up documentation on what assorted registers enact. When you happen to peer some code the utilization of a register you have not seen earlier than, ogle it up here.
• Legitimate SNES Developer Manual — It must always even be laborious to search out issues, but this is perchance the most authoritative supply for how the SNES works.
• Tremendous NES Parts — A playlist of videos explaining on the topic of all of the aspects of the SNES, at the level of component that is functional for programming for the SNES. Successfully payment searching at via.
• SNES Articulate Wiki — Highly variable in quality, but huge.
• Assembly for the SNES — A fracture route in 65816 meeting because it pertains to the SNES. Quick, and price discovering out/skimming via whenever you have to additionally very properly be not familiar with 65816.
• 6502 Opcodes — Invaluable reference, since the 65816 is backwards fancy minded with the 6502.
• 65816 Primer — Fills in the 65816-explicit parts that the above doc would not have.
• lorom-template — A example game. The code is rather complicated, but it and not utilizing a doubt could also be functional to ogle at every so continually.
• SNES programming manual — nesdoug — I even have stumbled on some complications with this code, and I gain it complicated to read, but for your whole, it is a functional example.
• SNES Assembly Skedaddle — A series of blog posts great fancy this one, but in extra component. I have not read most of it, but it and not utilizing a doubt appears to be like to be functional.
• snes-hello — Hey World for the SNES. The initialization code is mistaken, sadly, but it and not utilizing a doubt’s a straightforward example of making a tileset.

You develop not must always read all of these — most of this is extra reference topic material than anything — but it and not utilizing a doubt’s functional to know that it is there.

Code

With that out of the vogue, let’s dive into the code! You are going to also gain your whole thing on GitHub. I counsel skimming all of it now so that you have to even have gotten a overview for your head, then coming support to this to read the reason, but you have to additionally very properly be welcome to enact whatever you wish to have.

There are six predominant files:

• registers.inc: Aliases for most of the SNES registers.
• macros.inc: Some macros for switching between 8 and 16 bit modes, since I gain the meeting instructions laborious to be aware.
• init.asm: Initialization code, which locations the SNES into a fairly consistent articulate when it boots up. It be very straightforward — most other folks would use one thing extra complicated — but that is solely for being in a articulate to know what it is doing.
• predominant.asm: That is the build the action happens! It makes the display conceal red, then waits without fracture.
• header.asm: This defines the ROM header, with the title of the cartridge, miscellaneous recordsdata, and the vector table.
• lorom.cfg: The linker configuration, which defines guidelines on how to mush all of the meeting collectively into the closing ROM file, in what is fundamentally referred to as a “LoROM” format.

The registers.inc and macros.inc files needs to be fairly self-explanatory, so I could also not wretchedness talking about them extra. The header file is highly much less self-explanatory, but whenever you ogle at documentation for the header format, it needs to be fairly clear what it is doing. The principle cause you have to must always edit this in the fracture is altering the title of the ROM or altering the interrupt handlers.

With these out of the vogue, let’s ogle at init.asm. We birth out with sei to disable IRQs, and then enact clc, xce to transition from the 6502-fancy minded mode to 65816 mode (this is appropriate a magic incantation). cld disables decimal mode — I’m not 100% sure that is wanted, but it and not utilizing a doubt appears to be like to be simply, you constantly develop not could have to be in decimal mode.

After that, we mostly appropriate living a bunch of registers to zero — they are going to be initialized to random values on boot, so we living them to zero to have a ultimate slate. We furthermore turn off the display conceal and disable color math, which is frail for some transparency/etc outcomes.

As soon as our init code has scuttle, the remainder of the code in predominant.asm runs. This appropriate objects a color palette with a single color (red), turns on the level to, and loops without fracture.

In convey to living up the palette, we first write a 0 to the CGADD register to display conceal that we’re writing to the zeroth color, and then we write two bytes to CGDATA with the color. The SNES makes use of 15-bit color in a BGR format, which is rather odd, but works lovely when you catch frail to it. The SNES robotically increments the color it is writing to must always you write to CGDATA, so that you have to additionally write one other color by copying appropriate the two pairs of lda and sta commands, without writing to CGADD. Truly, this is the cause that writing to the same register twice in a row is very considerable — we’re not appropriate overwriting the extinct tag, as a consequence of writing to CGDATA causes the CGADD handle to increment.

Most communique with the SNES works fundamentally fancy this — it is all appropriate writing to and discovering out from registers.

This needs to be ample to catch you began. In the following part, I’m going to stroll via rendering some graphics on the background layers. Sooner than that, though, I could counsel taking part in with the code rather:

• Swap the color to one thing prettier than red.
• Write a macro to add a color to the palette extra without complications.
• Swap the palette in the busy loop.
• Stare at about a of the initialization routines in the examples linked above.
  • Work out what they enact in a utterly different procedure from my straightforward example.
  • Gather and fix the trojan horse in the “hello-snes” init routine, which causes it to not work on Mesen-S.
  • Receive your own init.asm file that makes you exclaim material.

Whereas you have to even have gotten played around to your pride, study part two to catch some graphics going!