I am a owner of Atari ST, and I would like to know software and tools used for the programmers for this computer to program mainly video games.
For example:
I can only really answer from my own perspective, and I only wrote real code (other than simple BASIC programs) on an Atari over the last couple of years.
In terms of classic tools IDEs were relatively light compared to tools you get today. I worked using Devpac 3, which is a good assembler that includes some useful features and a debugger. STOS could be regarded as a BASIC IDE specifically for games, and GFA BASIC offers pretty much everything you need form a coding/debugging point of view in one place.
BASIC and/or 68k Assembly. I'm sure there were/are some games written in C, but most people seem to prefer the lower barrier of entry offered by BASIC, and from there tend to head full-on into assembly language.
Atari Forum's WIKI has some useful documents and tutorials, and the #atariscne IRC channel on Freenode has some very smart people in it!
Checkout the Dead Hackers Society's Coding files section for tools and libaries to get you started.
DML (aka Douglas Little) recently published AGT (Atari Game Tools); a suite of graphics tools and a C based engine for quickly prototyping games on the Atari STE. The wiki includes some tutorials and you'll have sprites on screen in no time.
If you develop on the Atari then you'll be building an Atari executable file so you'll be able to simply launch it with a double click. I personally wrote some C and assembly on my Atari, but I ran into issues with screen mode switching and using the debugger for my game (I was working on a Falcon in 256 colour mode). Later on in my project I wrote the code in Devpac but running under the Hatari emulator, that meant I could use Hatari's debugger to work through issues.
I used to program on the Atari about 20+ years ago, so I might be a bit rusty on the subject. Also I used to mainly write demo effects and music, so I wasn't working on core game development directly (other than writing music for some).
IDE is a more modern concept, so you probably won't find one on the platform itself, but there are some out there for cross development. For Basic there were a couple of editor/interpreter combos (aside from the original Atari Basic), most notably GFA Basic and Omikron Basic, the latter of which was made the official Atari Basic at some point later. For Assembler the two main tools in use were Devpac and TurboAss(embler), both of which integrated editors and debuggers. In the case of TurboAss the debugger was even reset safe, so in case your program did something weird (short of overwriting the debugger code) you could hit reset and find yourself back in the debugger. Pretty nifty!
Language for games development was mainly Motorola 68k assembly (out of necessity, since most higher level languages had too much overhead to perform well), and some C. I only learned C much later, so can't tell you more about those tools. I did Basic for a while and then straight to assembly! :)
A good place to start looking is http://www.atari-forum.com, which is where a lot of the active crowd is hanging out (both demoscene and hobby games devs).
Like @LaceySnr wrote, just double-click the executable, or start it directly from Devpac/Turboass. Turboass has the Alt-A shortcut to run. There seem to be some home-made link cables in use where people cross compile/assemble on PC and then transfer the binary into the real machine to run there. See post by "Leonard" here: http://www.atari-forum.com/viewtopic.php?f=68&t=7152
Hope that helps!
Gunnar
I used, and still have, the Laser C compiler for Atari ST. It is the later version of what was first branded as the Megamax C compiler. It was/is actually a pretty good C dev environment. It has quite a few libraries for useful functions and relevant stuff for the hardware and OS.
I very much enjoyed this blog post which discusses how to get started with 68k assembly and DevPac3. The learning curve with assembly is very steep, but it does offer you the best performance.
If you want a gentler introduction to ST games programming, I can recommend STOS. It's a flavour of BASIC specifically designed for creating games.
I used DevPac all along for assembler and GFABasic for the tools. I remember that the Omikron basic was very popular in Germany. A lot of people starting had hopes with STOS, but I never got into it.
If you're familiar with BASIC, "STOS" is probably your best choice, but it has its limitations, unless you know a little regarding assembly, in which case you can combine the two. 100 % assembly gives best results, but it's a hassle to debug. 8 Mhz processor remains 2 Mhz efficent, because it takes 4 CPU cycles per instruction : fetch, decode, execute and write. Nevertheless, go with STOS. It does most of the work for you, and you can use the compiler afterwards to make your game quicker.
During my Atari times (from Mega-S2 to TT030) I used mainly these 3 programming languages/environments:
GFA-Basic.
Nice structured Basic with complete features for sound and graphics. Integrated IDE and cheap compiler. Was updated also to run on TT and Falco (Omikron BASIC the other widespread Basic variant on ST was much more problematic in that regard).ST-Pascal from CCD. Good solid Pascal not Turbo compatible but good enough to do all my work for University at that time. No integrated IDE, I used the text editor Tempus which was the best text editor on ST.Turbo-C/Pure-C. Yes, Borland had ported Turbo-C to the Atari-ST. Borland sold later the product to the German company ASH who renamed it Pure-C. It had the best code generator of all C compilers. It was also one of the few C Compilers on the platform that were ANSI-C89 conforming. The IDE with its project management was excellent and was updated also for TT and Falcon. I used it professionally for embedded things long after Atari faltered.
Oh common, you people just can't seem to take any kind of joke.
All the tools I referenced in my previous post were real.
Even thought Signum debugger was not used by many people and largely forgotten it seems. Probably for that name was also used by a virus and a well known unrelated tool.
As I wrote, Signum debugger was a text based assembly debugger working very much like the command line debug on DOS based systems See: https://en.wikipedia.org/wiki/Debug_(command)
Remember that there was no internet at that time, even BBS were a relatively "high-end" new thing and not many people used modems back then. Softwares were sometimes bought in shops but most often copied from a friend to another friend and then another...
A simple file edit could have given several names to this tool, hard to tell for the lack of other source of information... I myself barely used it in the late 80's before I got my hands on DevPac's MonST debugger which had a lot more friendly user interface.
My joke regarding the C language revolved around the fact that most developers used DevPac which was centered around 68k assembly programming.
And the acronyms group names were a reference to things like TCB, TNT, TLB that were kind of big names on this platform at that time.
GFA basic was also used indeed but mainly for tools I believe. For that matter I also remember that there also was a GFA assembly / debugging tool around released in 1988 IIRC.
Which I remember seeing people use at Ocean for the development of the Atari-ST version of Pang! (A game with balloons bouncing around that you had to pop)
A-Debug was a tool released by Brainstorm and was an improvement on Devpack's MonST in various ways. Its most useful feature was to be able to run entirely without the Atari's system and with every interruptions disabled (IPL:7)
As long as the memory containing the program itself was not overwritten. There was no programmable memory protection of any kind at that time, only hardcoded stuff in the MMU. And every program had to share the same flat, fixed addresses memory space.
I'd say that 90% or more of applications were written in Assembly mainly using DevPac. Regarding C (Turbo C was the tool IIRC?) it was probably making the bulk of the relatively small remaining part.
There also was the STOS which I got with my first Atari-ST. But I barely ever used it see: https://en.wikipedia.org/wiki/STOS_BASIC
You need to take into account that compilers at that time were not particularly good at any kind of optimization and running on extremely limited computers compared to today's standards.
I.E. 8mhz processors with a two byte cache (prefetch), requiring a minimum of 4 cycles per instruction and sharing the only bus with the chip in charge of the display (not even a "blitter" (as per STF versions at least, STE had a small one) to do any kind of graphic operation, no just a chip to actually send the pixels to the monitor's screen, a "shifter")
Add to this the fact that everything, The dynamic data used by the bios, xbios, higher TOS functions (Trap#1) and eventually the GEM on top of any program including all of its data, had to fit in an astounding 0.5 Mega bytes of memory... Guess why people were using assembly programming to squeeze every ounce of performance they could...
I reckon that this is kind of an old thread and could be seen as necro, however this is related to computers that are soon to be a 40 years old topic...
Anyway, enjoy yourselves.
