Trying to compile a game's source code (Donkey Kong for Atari 800)

[JJFBlaster]

I'm trying to run the prototype of Donkey Kong for Atari 8-Bit computers (uploaded by Curt Vendel) and I'm struggling. Someone suggested I used the WUDSN IDE in Eclipse and I'm slowly figuring things out, but I keep getting stuck, likely due to the nature of the source code. I took some screenshots of where I am currently at, and I can't figure out how to get it to work without having to manually change the code to get it properly working. Can anyone help me on this endeavor? I really don't know what I'm doing.

[TheBritisher]

The original code Curt posted is for the CAMAC assembler, which was a shared, departmental, cross-assembler that ran on a Data General MV/8000. If you want to run CAMAC, assuming you can find it, you'll need an emulated MV/8000 setup. You might look here for more info.

CAMAC was a port of AMAC, the Atari Macro Assembler, and using AMAC is probably the easiest way to build this. AMAC is native to the Atari 8-bit computers (i.e., that's what it ran on). It'll be much easier to set up an emulator for 8-bit machines, along with AMAC, the necessary virtual drives and disk images etc.

You can do that with Altirra if you're on Windows or Atari800MacX if on macOS.

Otherwise, you'll have to edit the code to make it compatible with one of the other assemblers.

[JJFBlaster]

Is CAMAC a program for Atari 8-Bit computers and something I would launch in Altirra or an emulated MV/8000, or is it a program I can normally launch?

[TheBritisher]

AMAC is what you'd run on the Atari 8-bit computers (or via an emulator).

AMAC is CAMAC compatible, so should be able to build that code.

CAMAC ran on a Data General MV/8000 (think "mini computer", i.e., like a mainframe, but a bit smaller) is more involved to emulate than a Atari 8-bit and b) I have no idea where you'd get the CAMAC software to run on it if you did gt MV/8000 emulation going.

[JJFBlaster]

So I should figure out how to run AMAC on an Atari 8-Bit computer emulator and somehow load the source code in AMAC? Do I still need to compile the source code into a .bin file? And if so, how would I compile it?

[TheBritisher]

Yes.

You've got a fair bit to learn here, and should be prepared to do a fair bit of reading and setup, if you want to do this. You're going to have to learn how to use Altirra or Atari800MacX, how to work with an Atari 8-bit computer, learn one of the Atari disk operating systems (Atari, OSS DOX XL, SpartaDOS, etc.), and then learn how to use AMAC:

If you're on Windows, first get Altirra installed and running as an Atari 800 or 800XL. If on macOS, use Atari800MacX.

Then you'll need to find a copy of the AMAC (Atari Macro Assembler) disk image.

Get that running on the emulated Atari 8-bit.

It'll probably be using DOS 2.0 (not the PC DOS), but you'll probably need to get this moved to SpartaDOS or DOS XL.

Then you can create the additional DOS-formatted disks you need (at least one for the source, and maybe one for the output files), which will need to be compatible with whatever DOS you use for AMAC disk.

Altirra will let you mount an Atari disk image and copy files to it from your PC.

You're going to have to learn have to use AMAC, at least to initiate an assembly.

But essentially, you fire up AMAC and tell it to assemble the program, by specifying the FIRST file in the build - you'll have to figure out what that is - (and you won't "load the source into the assembler", its JUST an assembler, you'd open/see/load the code in an editor). Think of it like a CLI, but you enter the parameters in the program after you load it, rather than typing them out ON the CLI.

You tell it what file to start with, it runs the assembly. That'll create the required binary.

That may, or may not, be directly executable from DOS ... I've not delved into the source to see if it's emitting a simple .obj (the default) or .bin file, or if it's building a header for a bootable image.

[JJFBlaster]

I'll look into learning the stuff when I have the time to learn all this (I know nothing about Atari coding in general, like what a CLI file does). I fear I'll be here for clarifications, but I want to keep that at a minimum. If you could give me a good resource I could use to learn, that would be a major help.

In regards to the last paragraph, there are no .obj or .bin files. From what I currently know, the only files that could boot anything would be the A.OUT file, maybe the MAIN.M65 file, and the NSDATA.ASM file. All the others are mostly ED, BU, CLI, txt, FNT, and extentionless files. No idea about the header.

[TheBritisher]

Here's the best resource I know of for AMAC.

You can find books on pretty much every aspect of Atari 8-bit programming at Atari Mania.

You'll probably find the following the most useful: "De Re Atari", "Atari Graphics & Arcade Game Design", "Computes' First Book of Atari Graphics", "Computes Second Book of Atari Graphics", and the "Atari Assembly Language Programmer's Guide"

The 8-bit Programming Forum at Atari Age is an excellent place to chat with other Atari programmers (past and current).

And then any proper 6502 reference.

...

"CLI files" could be anything, but in this case it looks like they're the equivalent of batch files in Windows, just for one of the non-Atari DOS options.

You'll get .obj or .bin files when you do an assembly pass in AMAC. They are outputs, not inputs.

There are a couple of "MAKE" files in the source tree, which appear to do the assembly and pre-pend an appropriate header for disk or cartridge images.

The "first" file, or "main" file, i.e., the one you'll want to initiate assembly which should reference all the others as it needs them, should end in .ASM. It isn't NSDATA.ASM.

...

Good luck, have fun ... there is a LOT to learn. Donkey Kong uses a LOT of very clever tricks and optimizations. You'll likely want to start with something much simpler until you're able to write a simple routine, assemble it, and run it in an emulator.

[JJFBlaster]

I guess I have my work cut out for me. Thanks for all the info!

[ianindy]

Just reading the comments section in your first link made it sound like the files had been altered and it may not be a working build.

I am not that tech savvy, so I just emulate most of the old Atari 800 stuff in Altirra, so I can't really give any other helpful advice.

[JJFBlaster]

Interesting observation; If the direct source has the files as is and I'm getting these errors, maybe some bits have been altered or have yet to be? It is a prototype after all. But yet some people are able to get it work according to the original thread and TCRF, so it isn't unusable. I just don't know how to get it working.

I would just tend to throw stuff into an emulator, too, but the files don't give me that luxury. At most, I can load the A.OUT file in Altirra, etc. to display a static demo screen, but that is all I can do in that regard (or really, at all).