kenjennings

Ditto that. Natively building on an Atari has a number of inconveniences to enjoy from the 80s (line numbers, limited editor, limited memory, limited disk space, slow assembly time, etc.) In the 80s that's all there was and we liked it (uphill, in the snow, in both directions.) Today I use Eclipse/WUDSN with atasm and the Atari800 emulator on linux for writing, building, and testing 6502 assembly. atasm is Mac/65 with all the joy and none of the line numbers.

You need to write the assembly routines elsewhere (Mac/65 Atari Assembler/Editor, etc.), load them into memory on the Atari, then call them from BASIC using USR(). I did a series of tutorials around making simple Assembly language USR() routines supporting Atari BASIC. The last sections are specifically about what's wrong with XIO and how to use the OS CIO routines successfully (with and without XIO.) http://atariage.com/forums/blog/576/entry-13175-part-1-of-11-simple-assembly-for-atari-basic/ Part 1: Intro Part 2: Overview of common Assembly instructions Part 3: The environment inside a USR() call. Part 4: Implement DPEEK() (16-bit, two-byte PEEK()). Part 5: Implement DPOKE (16-bit, two-byte POKE). Part 6: Implement several bit-wise operations. Part 7: Implement conversion from integer to hexadecimal text Part 8: Implement conversion from integer to bit string/text Part 9: Implement memory copy Part 10: The problems with XIO, and using CIO (part I) Part 11: The problems with XIO, and using CIO (part II).

atf2code An over-engineered linux tool to convert an Atari 8-bit font to BASIC, C, and Assembly source. (Should be easily build-able on anything that supports C.) https://github.com/kenjennings/Atari-Font-To-Code The example text files there show complete output of the E000 character set including all the comment options. If anyone does use this let me know if something doesn't work. And bin2code This is another overdone linux tool that does output similar to atf2code, but works on any binary data without assuming the data is for a font. This does better at graphics bitmap data than atf2code. https://github.com/kenjennings/Atari-Binary-To-Code

What?!! It ignored 20 available colors?! :-)

As far as Mapping The Atari goes location $00 is mostly unused. I think the code intends to reference this to get the frame counter speed set by other code (i.e. to allow a BASIC program to change the behavior of this routine.) So, setup for this should initialize $00 to a non-zero value.

I kid you not, in 1985/86, Asteroids was THE party game in our dorm. I was probably the only computer geek on speaking terms with the football jocks. Pretzels, beer, and 4 player asteroids combat. The asteroids were entirely inconsequential. We played it like Space War.

It is resetting the "count" delay to whatever is stored in the location labelled "speed" which is memory address $00. What value is there? If it happens to be 0, then "count" is being initialized to 0, and your delay loop will decrement that to $FF, and then it won't make it back to 0 for another 255 frames .

My favorite "benchmark" was the Dead On Arrival/Failure Out Of The Box industry stats that one of the multi-platform magazines published. Wish I could remember which one that was. I recall not many computers came close to the reliability of the Ataris.

It is a benchmark running in BASIC. By definition it totally wastes the performance of whatever computer it runs on. Did I mention this is BASIC? The purpose of a benchmark in BASIC (wow, that's an oxymoron, isn't it?) is to evaluate how poorly BASIC performs. (and by extension the other things we know that affect this, like the difference a slow floating point library makes.) AND, some kind of ballpark figure measuring BASIC was actually a useful goal back in the day. In the 70s/early 80s a major purpose of 8-bit computers was to run BASIC. In fact, for some computers BASIC was the operating system and user interface for users. Many, MANY people buying 8-bit computers would not make it as far as assembly coding, (unlike the rest of us basement dwellers without meaningful social lives,) so a general comparison of BASIC languages was a reasonable, if not precisely accurate yardstick to evaluate their user experience. Today, its primary function is as gasoline for a burning debate on efficiency.

Duran Duran would have loved it. :-)

I don't have cc65. From what you describe it sounds like cc65 uses the Atari OS CIO to open graphics modes. Any BASIC language documentation referring to the graphics mode numbers should be good to use, since it is the OS, not BASIC that is creating the graphics modes. Simply, you get graphics modes numbered 0 through 11 on Atari 800/400, 0 to 15 on XL and XE. Mode 0 is the usual 40x24 text mode. What you described as monochromatic text. Mode 1 and 2 are colored text modes. Modes 3 to 7 are regular graphics modes (black background by default). Mode 8 is the highest resolution mode which uses the same color scheme as the monochromatic text mode (blue background, white pixels). The modes from 1 through 8 automatically include four lines of "monochromatic text" at the bottom of the screen. Add 16 to the graphics mode number to remove the text window at the bottom of the screen. On computers with GTIA (which by now is almost every 8-bit Atari available) modes 9, 10, 11 are graphics modes with special color options. None of these include the text window at the bottom of the screen. On the XL/XE there are also modes 12, 13, 14, 15. Two are text modes that really require custom character set to be effective, and two are graphics modes.

The most important thing I saw.... Mmmmmmm. Real paddles. Nothing substitutes for real paddles.

Does it support anyone creating/adding a new palette? There's a Load button on that window.. (Why? And why is it ghosted?)

I've stopped doing any coding/building on native hardware due to eclipse, wudsn, and atasm on linux. (and the Atari800/Atari++ emulators.) (atasm is all the joy of Mac/65 with none of the line numbers.) Edit stupidly huge source files in Eclipse, or Kate, and then build and run in a second or two. It's like angels singing.

When I built the CheapTalk voice synthesizer from magazine directions in the 1980s the RS store in my neighborhood was like an electronics grocery store. There were aisles, many aisles. The store had little shopping carts. Everything I needed, and piles of things I didn't even know about. And then it became a crappy R/C toy and cell phone store. Parts became one wall panel filled with earbuds and video cables.

Love Mac/65. Super for small things, even in an emulator. But my tutorial projects have become larger and larger -- not necessarily the code, but the comments. Recently, I was doing something relatively minor and Mac/65 couldn't build it, because it ran out of memory -- used up by all the tutorial comments. Since I'm mostly using linux I started using atasm -- all the joy of Mac/65 with none of the line numbers!

FYI: There is a simple Atari BASIC Player/Missile programming example here: http://atariage.com/forums/topic/221650-valentines-day-programming-project/?p=2921214

I use eclipse/wudsn/atasm on linux. Works great. When I'm editing on the PC I use Notepad++. I put together a few syntax hilighting configurations. Atari BASIC, BASIC XL, and atasm. I exported the configa and put them on github here: https://github.com/kenjennings/NotepadPlusPlus-Atari-Syntax-Highlighting The atasm syntax hilighting is fairly complete. Not too sure about the BASICs. I don't use them very often.

Yup. Even if data is worked down to strings in data statements or assignments there is still redundant data. The most efficient use of memory is having no string data staged as DATA or assignments. Instead, put it in a file (or files) and read it at startup. Unfortunately, Atari BASIC is brain damaged when using CIO to put/get arbitrary lengths of binary data, so a program has to do it the slow way and GET one character at a time. (OSS BASIC XL and others have working Bget commands that fix this.) I posted a bit of blather about this in the blog including a new version of XIO that does what it should, here: http://atariage.com/forums/blog/576/entry-13185-part-10-of-11-simple-assembly-for-atari-basic/

Not sure when I'll have time to look, but I'll find it someday.

Also, the double quote character. CHR$(34) ?

Just guessing/speculating.... What ANTIC does is defined by the speed of the entire system. It does what it does based on the DMA time available in the system. Things that a superdeedooperdee ANTIC would do that need more DMA would probably need the entire system, bus, and memory running 2x or 4x or more times faster in order to provide the necessary data/DMA time. At that point we have an Amiga. :-) (not that that's a bad thing ).

Easy assembly tutorials? http://atariage.com/forums/blog/576/entry-13175-part-1-of-11-simple-assembly-for-atari-basic/ It's hard to present these things to someone who does not understand. Let me know if how easy/understandable this is.

You could create a binary load file. PUT the $FF $FF bytes for the header to the file. PUT the low byte then high byte of the starting address. PUT the low byte then the high byte of the ending address. (Starting address + number of Bytes - 1) Then PUT the bytes values of your data. For the sake of just loading the file into memory it doesn't matter much if you you don't recall the actual starting address of the machine code. Once you get it into a load file you can put it into memory and look at it with all kinds of debuggers. That should help figure out what the real addresses should be.

This would be interesting if someone can find it. According to IMDB the original show was on in 1978 and 1979. The Atari 8-bits came out in late 79, so it would have been difficult for them to have the computers during production. If they did, it probably would have to be a prototype... which would be awesome to have Atari 8-bit graphics on film in 1979. I read that after a write-in campaign there was another set of episodes made in 1980. It is more likely that Atari graphics could appear in these shows. There is a list of shows on wikipedia. Several plots mention children from the Galactica. https://en.wikipedia.org/wiki/List_of_Battlestar_Galactica_%281978_TV_series%29_and_Galactica_1980_episodes As much as I like the show I'm not going to sit through hours of it to find the graphics. A job for someone else who loves the series more.