So, you want to program the Atari 2600 and don't know where to start? You're in the right place! Welcome to the first instalment of the "Atari 2600 Programming for Newbies".
My evil alias is "Dr Boo", and I've been developing games for various computers and consoles since the late 1970s. I'm going to introduce you to the arcane world of programming the '2600 in assembly language, and slowly build up your skills so that you can start to develop your own games. We'll take this in slow easy stages, so don't be shy.
These days there are excellent alternatives to programming in assembler - in particular, bAtari BASIC (bB), which lets you program in a BASIC-like language and use pre-defined kernels. bB abstracts some of the hardware layer away so that you can concentrate more on game mechanics, but does introduce limitations to what you can do. It's a great place to start, so you should look there first if you're new to programming and/or you just want to get a feel for the limitations of the machine. But if you're ready for the big time, assembly language it is, so let's get started.
Developing for the Atari 2600 is much simpler today than it was when the machine was a force in the marketplace (ie: in the 1980s). We have a helpful online community of dedicated programmers, readily available documentation, tools, and sample code - and online forums where we can pose questions and get almost instant feedback and answers. With a bit of dedication effort, anyone can do this!
It is this online community which makes developing for the machine 'fun' - though I use that in the broadest sense of the word. My 'fun' may be another man's 'torture'. For, programming this machine is tricky, at best - and not for the feint of heart. But the rewards are great - making this simple hardware do anything at all is quite an achievement - and making it do something new and interesting gives one a warm fuzzy feeling inside.
So, let's get right into it... we're going to assume that you know how to program something, but not much more than that. We'll walk through binary arithmetic, hexadecimal numbers, machine architecture, assemblers, graphics, and whatever else gets in our way. And we'll probably divert on tangential issues here and there. But hopefully we'll come out of it with a greater understanding of this great little machine, and some appreciation for the work of those brilliant programmers who have developed the classics for this system.
The Basics
A game on the '2600 comes in the form of a cartridge (or "tape") which is plugged into the console itself. This cartridge consists of a circuit board containing a ROM (or EPROM) which is basically just a silicon chip containing a program and graphics for displaying the game on your TV set. This program (and the graphics it shows on your TV) are really just a lot of numbers stored on the ROM which are interpreted by the CPU (the processor) inside your '2600 just like a program on any other computer. What makes the '2600 special is... nothing. It's a computer, just like any other!
A computer typically consists of a CPU, memory, and some input/output (I/O) systems. The '2600 has a CPU (a 6507), memory (RAM for the program's calculations, ROM to hold the program and graphics), and I/O systems (joystick and paddles for input, and output to your TV).
The CPU
The CPU of the '2600 is a variant of a processor used in computers such as the Apple II, the Nintendo NES, the Super Nintendo, and Atari home computers (and others). It's used in all these machines because it was cheap to manufacture, it's simple to program, but also effective - the famous "6502". In this course we will learn how to program the 6502 microprocessor... but don't panic, we'll take that in easy stages (and besides, it's not as hard as it looks).
The '2600 actually uses a 6507 microprocessor - but this is really just a 6502 dressed in sheep's clothing. The 6507 is able to address less memory than the 6502 but is in other respects exactly the same. We'll just call it the CPU from now on, unless we need to distinguish between the two variants.
Memory
Memory (both ROM and especially RAM) is severely limited on the '2600. When the machine was developed, memory (both ROM and RAM) were very expensive, so we don't have much of either. In fact, there's only 128 bytes of RAM (and we can't even use all of that!) - and typically (depending on the capabilities of the cartridge we're going to be using for our final game) only about 4K of ROM. So, then, here's our first introduction to the 'limitations' of the machine. We may all have great ideas for '2600 games, but we must keep in mind the limited amount of RAM and ROM!
Input/Output
Input to the '2600 is through interaction by the users with joystick and paddle controllers, and various switches and buttons on the console itself. There are also additional control devices such as keypads - but we won't delve much into those. Output is invariably through a television picture (with sound) - i.e.: the game that we see on our TV.
So, there's not really much to it so far - we have a microprocessor running a program from ROM, using RAM as required, for the storage of data - and the output of our program being displayed on a TV set. What could be simpler?
The Development Process
Developing a game for the '2600 is an iterative process involving editing source code, assembling the code, and testing the resulting binary (usually with an emulator). Our first step is to gather together the tools necessary to perform these tasks.
'Source code' is simply one or more text files (created by the programmer and/or tools) containing a list of instructions (and 'encoded' graphics) which make up a game. These data are converted by the assembler into a binary file which is the actual data that can be placed on a ROM in a cartridge, and is run by the '2600 itself.
To edit your source code, you need a text-editor — and here the choice is entirely up to you. These days I use an IDE supported by the community Atari Dev Studio, as I like its features - it provides an all-in-one cross-platform solution to '2600 development... but any text editor is fine. Packages integrating the development process (edit/assemble/test) into your text editor may be available, and this integration makes the process much quicker and easier (for example, Developer-Studio integration allows a double-click on an error line reported by the assembler, and the editor will position you on the very line in the source code causing the error).
To convert your source code into a binary form, we use an 'assembler'. An assembler is a program which converts assembly language (a list of human-readable text) into binary format (and in particular, since the '2600 uses a 6502-variant processor, we need an assembler that knows how to convert 6502 assembly code into binary). Pretty much all '2600 development these days is done using the excellent cross-platform (ie: versions are available for multiple machines such as Mac, Linux, Windows, etc) assembler dasm which was written in about 1988 and has been supported by the Atari community ever since. It is certainly one of the older still-in-use pieces of software out there.
Grab the latest copy of dasm now from dasm 8-bit macro assembler. Once you expand the archive, you will see a directory named machines and inside this a directory named atari2600. The files in that directory are support files support-files for '2600 development; in particular we are going to be using vcs.h and macro.h to make our life a lot easier. In this course, we will be using dasm exclusively, so we'll learn how to setup and use dasm shortly.
Development of a game in the '80s consisted of creating a binary image (ie: write source code, assemble into binary) and then physically 'burning' the binary onto an EPROM, putting that EPROM onto a cartridge and plugging it into a '2600, cursing and then starting the whole process again. This was an inherently slow process (trust me, I did this for NES development!) and it sometimes took 15 minutes just to see a change!
Nowadays, we are able to see changes to code almost immediately because of the availability of good emulators. An emulator is a program which pretends to be another machine/program. For example, a '2600 emulator is able to 'run' binary ROM images and display the results just as if you'd actually plugged a cartridge containing a ROM with that binary into an actual '2600 console. Today's '2600 emulators are very good indeed. So, instead of actually burning a ROM, we're just going to pretend we've burned one - and look at the results by running this pretend-ROM on a pretend '2600 - an emulator. And if there's a problem, we go back and edit our source code, assemble it to a binary, and run the binary on the emulator again. That's our iterative development process in action.
There are quite a few '2600 emulators available...
Stella the emulator we will be using for this tutorial series
Gopher2600 an emulator for the Atari 2600 written in the Go language
JavAtari - the online Atari 2600 Emulator
Grab yourself a copy of Stella now, and install it on your machine. We'll learn how to use Stella soon, as well - but right now let's continue with the gathering of things we need...
Now that we have an editor, an assembler, and an emulator - the next important things are documentation and sources for information. There are many places on the 'net where you can find information for programming '2600, but perhaps the most important are
AtariAge Forums
The Stella list - no longer active but a great historical archive of information,
Finally, we need some good reference documentation. The Stella Programmer's Guide is essential. It's the original technical documentation released for programmers back-then, and the awesome dasm manual is useful to help us understand what dasm can do for us.
OK, that's all we need. Here's a summary of what you should have...
- [https://marketplace.visualstudio.com/items?itemName=chunkypixel.atari-dev-studio||Atari Dev Studio]
- dasm assembler and the '2600 support files.
- Stella emulator
- The Stella Programmer's Guide document
- Bookmarks in your browser to to AtariAge and the #Stella mailing list.
That's it for this session. Have a browse through the Stella Programmer's Guide (don't be daunted!), and try installing Stella (and play a few games for 'research' purposes). Next time we will make sure that our development environment is setup correctly, and start to discuss the principles of programming a '2600 game.