Jump to content

Search the Community

Showing results for tags 'Atari 8-bit'.



More search options

  • Search By Tags

    Type tags separated by commas.
  • Search By Author

Content Type


Forums

  • Atari Systems
    • Atari 2600
    • Atari 5200
    • Atari 7800
    • Atari Lynx
    • Atari Jaguar
    • Dedicated Systems
    • Atari 8-Bit Computers
    • Atari ST/TT/Falcon Computers
  • Gaming General
    • Classic Gaming General
    • Classic Computing
    • Modern Gaming
    • Prototypes
    • Arcade and Pinball
    • Emulation
    • Hardware
    • Gaming Publications and Websites
    • International
  • Marketplace
  • Community
  • Game Programming
  • Site
  • Classic Gaming News
  • The Club of Clubs's Discussion
  • I Hate Sauron's Topics
  • 1088 XEL/XLD Owners and Builders's Topics
  • Atari BBS Gurus's Community Chat
  • Atari BBS Gurus's BBS Callers
  • Atari BBS Gurus's BBS SysOps
  • Atari BBS Gurus's Resources
  • Atari Lynx Programmer Club's CC65
  • Atari Lynx Programmer Club's ASM
  • Atari Lynx Programmer Club's Lynx Programming
  • Atari Lynx Programmer Club's Music/Sound
  • Atari Lynx Programmer Club's Graphics
  • The Official AtariAge Shitpost Club's Shitty meme repository
  • The Official AtariAge Shitpost Club's Read this before you enter too deep
  • Tesla's Vehicles
  • Tesla's Solar
  • Tesla's PowerWall
  • Tesla's General
  • Harmony/Melody's General
  • ZeroPage Homebrew's Discussion
  • Furry Club's Chat/RP
  • PSPMinis.com's General PSP Minis Discussion and Questions
  • PSPMinis.com's Reviews

Blogs

There are no results to display.

There are no results to display.

Calendars

  • AtariAge Calendar
  • The Club of Clubs's Events
  • Atari BBS Gurus's Calendar
  • ZeroPage Homebrew's Schedule

Find results in...

Find results that contain...


Date Created

  • Start

    End


Last Updated

  • Start

    End


Filter by number of...

Joined

  • Start

    End


Group


Website


Facebook


Twitter


Instagram


YouTube


eBay


GitHub


Custom Status


Location


Interests


Currently Playing


Playing Next

Found 117 results

  1. I've been hinting that this was in the works for a while now. And I figure its time to start revealing a bit of what I have been working on for the last 1-1/2 years. I call it the 1088XEL. Why? Well for one thing thanks to Lotharek's U1MB board and the on-board 64K RAM, there is a total of 1088K of usable memory. Basically the idea behind this project is to create something that is designed from the ground up to accept some of the most popular upgrades as plug-in daughter boards. Yes no more making up wire harnesses, crimping terminals, scratching your head and trying to figure out where to mount things. The other goal of the project is create a very small footprint mother board. I'm talking about something in the area of 6" x 6" (15x15 centimeters). And to utilize only thru-hole components, as well as the original five A8 LSI chips (Sally, Antic, GTIA, Pokey, PIA). Actually there will be an additional Pokey on board to support Stereo Sound. If you've been following some of my other projects, then you've witnessed the nesting technique I wish to exploit when laying out this board, which is how I will get it shrunk down to such a small size without resorting to surface mount devices. The first prototype will initially be created as an NTSC version board, but will provide support for an upgrade path to PAL via a future daughter board design, an oscillator change, and of course PAL Antic and GTIA chips. I have taken some liberties at reducing the component count by eliminating capacitors, some support chips (through utilization of SRAM memory), and just not caring too much about RFI radiation issues. Me bad So for all intents and purposes this will still be a 'real' Atari 8-bit computer as far as the basic hardware is concerned (not an FPGA implementation). Now for the big reveal (please keep in mind that these are preliminary schematics, and that the design is still in flux, so in other words there might be a few mistakes and omissions )... - Michael
  2. Hi, I have the following items for sale: Atari 8-bit Computer Tape Games* EURO 20 European Countries and Capitals (Atari) TIB EURO 7 Meltdown (Cosmi) TB EURO 40 Richard Petty's Rennzirkus (Ariolasoft) TIB EURO 40 Strätos (Adventure International) TB (incl. Xerox instructions) EURO 15 The E Factor (Cosmi) TIB EURO 20 Zaxxon (Datasoft) TB * For more pictures just scroll down to the update post Atari Memorabilia EURO 25 Atari T-Shirt Berzerk (Size S, unused) EURO 25 Atari T-Shirt Defender (Size S, unused) Activision Patches EURO 10 Chopper Command EURO 35 Decathlon Bronze Make an offer Decathlon Gold EURO 10 Dragster EURO 25 Freeway EURO 20 Kaboom! EURO 30 Megamania EURO 125 Pitfal 2 EURO 25 Pitfall! Make an offer Robot Tank Star of Honor EURO 25 Spider Fighter EURO 70 Tennis EURO 50 Stampede Belt All patches are original, no repros. Atari 2600 Original Releases - Atari 2600 Reproductions EURO 175.00 Good Luck, Charlie Brown! - CIB - NTSC Made by CPUWIZ; #22, shrinkwrapped EURO 45.00 Music Machine - CIB - NTSC - Reproduction; Made by CPUWIZ *** Pending ***Atari 2600 Stella gets a new Brain Original Release (serial number #012, signed manual, very good condition): EURO 130 Atari 7800 - Atari Lynx Lynxopoly - complete: EURO 125 Atari 8-bit Computer Disk Wargame Construction Set (SSI) - complete: EURO 15 Springer - Tigervision/NTSC - CIB: EURO 60 The Great American Cross-Country Road Race - Activision/NTSC - DIB: EURO 25 Gauntlet: The Deeper Dungeons Data Disk - Mindscape/NTSC - DIB: EURO 35 Infiltrator - Mindscape/NTSC - DIB: EURO 30 Pinball Construction Set - Electronic Arts/NTSC - DIB: EURO 15 One on One - Electronic Arts/NTSC - DIB: EURO 15 Atari Standees + Mobile All items are made of cardboard (no posters) and all are original. The shipping to the USA (EURO 37) is so expensive because of the individual sizes are too big to ship as a small parcel/letter. Megamania – Activision 2600 – Standee – 31 cm x 22 cm – US – good condition – EURO 175 Merchandise Contra III Promo Puzzle from 1992 (shrink-wraped, bent because of the foil): EURO 100 Intellivision - Intellivision Poster - More Pictures For more detailed pictures please check this Gallery Please check also my other sale listings: Atari 2600 Reproductions + Homebrews Atari 5200 Prototypes Shipping Information I am located in Germany. The shipping options are: - GERMANY Regular Parcel (EURO 7.50) - EU Regular Parcel (EURO 17.00) - USA/CANADA Airmail Parcel (EURO 37.00, runtime about 14 to 21 days, insured, tracking) or Airmail Letter option for USA & Canada: I can offer airmail letter in robust box for 2 regular-sized boxed Atari games/parcel for EURO 4/parcel (no tracking, no insurance, runtime about 5 to 7 days) *** Payment Information Payment by Paypal/EURO only. If you have any questions, please drop me a PM. Exchange rate is about 1.00 EURO -> 1.20 US$ Be sure to check this topic from time to time, I am adding games on a daily base. Thanks for watching, Marc.
  3. Looks like a little over 18 hours are left on this eBay auction listed by seller "nintendolover." Looks like a part of that huge video game collection that the same guy was looking to sell complete but didn't have any takers at his astronomical price, so he appears to be splitting it up by system. It's currently at $510 and counting. Any ideas on what the winning bid will wind up being? Too rich for my blood and I have the system and a complete collection already, so I thought I'd point it out in case anyone was interested. Not mine, as my eBay ID is the same as my username here. Cheers. https://ebay.to/2WfWHG2
  4. Here I've got the Atari Corp. variation (1987 Copyright) of Defender for Atari 8-bit computers. It was sold to me as "new" but the top of the seal had a cut in it so I took out the contents to show you all. Don't think there are too many of the Atari Corp. small box version laying around. $30 OBO with free shipping. Please see the provided pics for exact condition and shoot me a PM if interested in discussing further. Thanks!
  5. I offer 30% discount on all remaining Atari 8-bit and C64 software. Just check the latest lists with the regular prices and deduct the 30% discount. ITEMS As some of you may know I've closed my online shop*. Now I'm selling off my stock. I start with the Atari 8-bit software (200+ items, a mix of US and Euro releases, just check the lists) and C64 items (250+ items, a mix of US and Euro releases, just check the lists). The pdf files contain detailed deskription and a picture of each item. The prices stated in the lists were the old shop retail price and of course, I am absolutly open for offers NEWS I've already received quite a few offers for selected games, but I would really like to sell the items in bulks with huge discounts, so please be patience if you've sent an offer for single or few games. SHIPPING I am located in Germany. Shipping USA/Canada: 5kg - 37.99 EUR; 10kg - 54.99 EUR; 20kg - 76.99 EUR Shipping EU: 5kg - 17,99 EURO; 10kg - 22,99; 20kg - 33,99; 31,5kg - 44,99 EUR If you have any questions just drop me a line. Thanls for reading, Marc. * The box business isn't effected by the closing of the shop. Shop_Atari_8bit_Software.pdf Shop_C64t_Software.pdf
  6. A quick note about the hacks: I have decided to place all of my hacks in one, convenient thread. As I grew up with my Atari 5200 and Atari 800XL, there were certain games that I thought had a little more potential. I had created basic hacks for a few of these games. I always thought that my 5200 Popeye could look better. Brutus didn't have a number "5" for a head in the arcade version. I knew I had drawn more accurate Mario characters on my 800XL. If only I could plug them into the games. I teamed up with Playsoft, who provided the tools and wisdom to make these games possible. Some of these games have other contributors. Tep392 helped us tweak the collision and touchy controls in DK Jr. I believe that Tep392 and Kjmann worked on the original Donkey Kong RMT sound version. I believe there is another member who helped Playsoft in some of the A8 to 5200 conversions. I am not sure who drew the giant Popeye head. If anybody has clarity on this, let me know, so credit can go where it is due. These are truly community projects, and I had a great time watching them transform. Playsoft did an amazing job of hacking display list interrupts, giving me a little more height area (eg. thicker 5200 Mario Bros floors, as well as multiple floor types). I have been holding off on releasing the latest Mario Bros hacks, because I didn't want to release as many revisions. I was also hoping for some upgraded sound effects for Mario, but there's not always enough time in the day. There's a bonus hack for the 7800 Mario Bros. I found the 7800 graphics tedious to hack. The characters were drawn too small and flat, and the game itself plays horribly. That version has the least number of animation frames, so the animation is poor regardless. It is my "Lipstick on a Pig" release. Donkey Kong: Atari 8-bit Computer Arcade version -- DK_A8_Arcade.xex Atari 8-bit Computer RMT version (Updated sound) -- DK_A8_RMT.xex Atari 5200 Supersystem version -- DK5200_Arcade.bin Donkey Kong Jr: (Arcade & Enhanced versions) Atari 8-bit Computer Arcade version -- DKJr_A8_Arcade.xex Atari 8-bit Computer Enhanced version -- DKJr_A8_Enhanced.xex Atari 5200 Supersystem Arcade version -- DKJr_5200_Arcade.bin Atari 5200 Supersystem Enhanced version -- DKJr_5200_Enhanced.bin Popeye Arcade: Atari 8-bit Computer version --PopeyeArcade_A8_Final.xex Atari 5200 Supersystem version -- Popeye5200_ArcadeFinal.bin Mario Bros (1983, 5200 version): Atari 5200 Supersystem bin version -- MarioBros_Arcade_52.bin Atari 5200 Supersystem car format -- MarioBros_Arcade_52.zip Mario Bros XE: Atari XL/XE version - MarioBrosArcade_XE.zip Mario Bros 7800: Atari 7800 version - Mariobros_7800_Arcade.a78
  7. M.U.L.E. disk dump working in emulation. Cover has seen much better days. Includes folio, disk, & quick reference card. I cannot smell anything, but may have been stored in parents home for a time, and they were heavy smokers. So, please expect smoke smell (though hopefully there isn't any.) Also, I have a cat, so cat dander is to be expected. Asking $25 + shipping & PayPal fees.SOLD
  8. Binary File I/O (Part 2 of 2) ============================================================== Part 1 - Introduction http://atariage.com/forums/blog/576/entry-13175-part-1-of-11-simple-assembly-for-atari-basic/ Part 2 - Learn 82.7% of Assembly Language in About Three Pages http://atariage.com/forums/blog/576/entry-13176-part-2-of-11-simple-assembly-for-atari-basic/ Part 3 - The World Inside a USR() Routine http://atariage.com/forums/blog/576/entry-13177-part-3-of-11-simple-assembly-for-atari-basic/ Part 4 - Implement DPEEK() http://atariage.com/forums/blog/576/entry-13178-part-4-of-11-simple-assembly-for-atari-basic/ Part 5 - Implement DPOKE http://atariage.com/forums/blog/576/entry-13180-part-5-of-11-simple-assembly-for-atari-basic/ Part 6 - Various Bit Manipulations http://atariage.com/forums/blog/576/entry-13181-part-6-of-11-simple-assembly-for-atari-basic/ Part 7 - Convert Integer to Hex String http://atariage.com/forums/blog/576/entry-13182-part-7-of-11-simple-assembly-for-atari-basic/ Part 8 - Convert Integer to Bit String http://atariage.com/forums/blog/576/entry-13183-part-8-of-11-simple-assembly-for-atari-basic/ Part 9 - Memory Copy http://atariage.com/forums/blog/576/entry-13184-part-9-of-11-simple-assembly-for-atari-basic/ Part 10 - Binary File I/O Part 1 (XIO is Broken) http://atariage.com/forums/blog/576/entry-13185-part-10-of-11-simple-assembly-for-atari-basic/ Part 11 - Binary File I/O Part 2 (XIO is Broken) http://atariage.com/forums/blog/576/entry-13186-part-11-simple-assembly-for-atari-basic-the-end/ ============================================================== New XIO in Mac/65 Assembler Code Many articles on this subject go by a simple route – use BASIC code to set up all the IOCB values for the 7/Get Bytes or 11/Put Bytes commands, and then provide a minimal assembly routine that simply calls the CIO vector. While BASIC mangles the binary read/write functions, XIO itself also is sufficiently broken to justify a complete machine language USR() routine that exercises CIO commands the way they were intended. For example, ICAX values are not always needed or even wanted, but XIO requires the values. In fact, ICAX values are rarely needed outside of the 3/Open command. Similarly, the filespec/buffer is often not necessary. This routine will perform the same purpose of XIO, but allow a variable number of arguments, adding more arguments only as needed: Always required (2 arguments): 1) Channel Number – Only low byte values 0 to 7 accepted. The high byte is ignored. 2) CIO Command – Only the low byte of the argument will be used. Optional (4 arguments): 3) Filespec/Buffer address – 16-bit value 4) Filespec/Buffer length – 16-bit value Additionally optional when the Filespec/Buffer is provided (5 arguments): 5) ICAX1 – the low byte of this argument is used. High byte is ignored. Additionally optional when the Filespec/Buffer and ICAX1 are provided (6 arguments): 6) ICAX2 – the low byte of this argument is used. High byte is ignored. Since the routine accepts 2, 4, 5, or 6 arguments it can support any of the following: 2) USR(NEWXIO,6,18) – Perform command 18/Fill for screen device (assuming channel 6) 4) USR(NEWXIO,1,254,ADR(F$),LEN(F$)) - Use channel 1 to format (254) the disk drive described by F$. This would also be the format/number of arguments needed for performing CIO Commands 7/Get Bytes and 11/Put Bytes. 5) USR(NEWXIO,5,3,ADR(F$),LEN(F$),6) - Use channel 5 to open (3) the disk directory (read/4 + directory/2 = 6) described by F$ 6) USR(NEWXIO,6,3,ADR(F$),LEN(F$),28,7) – Use channel 6 to open (3) as graphics mode 7 with a text window (read/4 + write/8 + window/16 = 28) assuming F$ describes “S:” Variable number of arguments means this program is organized differently from the prior utilities that copy stack arguments to Page Zero. Since this is just an interface for putting values into the IOCB it doesn't make use of Page Zero beyond returning a status value to BASIC. 0100 ; NXIO.M650105 ;0110 ; NEW CIO/XIO INTERFACE0115 ;0120 ; SETUP IOCB WITH THE SUPPLIED0125 ; ARGUMENTS AND CALL CIO0130 ;0135 ; USR 2, 4, 5, or 6 ARGUMENTS:0140 ; CHANNEL == IOCB CHANEL (LOW BYTE)0145 ; COMMAND == CIO COMMAND (LOW BYTE)0150 ; BUF ADR == ADDRESS OF BUFFER0155 ; BUF LEN == LENGTH OF BUFFER0160 ; ICAX1 == CIO ICAX1 VALUE (LOW BYTE)0165 ; ICAX2 == CIO ICAX2 VALUE (LOW BYTE)0170 ;0175 ; RETURN VALUE IS CIOV RESULT IN Y REG0180 ;0185 ZRET = $D4 ; FR0 $D4/$D5 Return Value0190 ;0195 CIOV = $E456 ; CIO Vector0200 ;0205 IOCB = $0340 ; Base IO Control Block0210 ICHID = IOCB+$00 ; Handler ID0215 ICDNO = IOCB+$01 ; Device number0220 ICCMD = IOCB+$02 ; ** CIO Command0225 ICSTA = IOCB+$03 ; CIO Status0230 ICBAL = IOCB+$04 ; ** Buffer address (low)0235 ICBAH = IOCB+$05 ; ** Buffer address (high)0240 ICPTL = IOCB+$06 ; Put char routine (low)0245 ICPTH = IOCB+$07 ; Put char routine (high)0250 ICBLL = IOCB+$08 ; ** Buffer length (low)0255 ICBLH = IOCB+$09 ; ** Buffer length (high) 0260 ICAX1 = IOCB+$0A ; ** Aux Byte 10265 ICAX2 = IOCB+$0B ; ** Aux Byte 2 0270 ICAX3 = IOCB+$0C ; Aux Byte 3 0275 ICAX4 = IOCB+$0D ; Aux Byte 4 0280 ICAX5 = IOCB+$0E ; Aux Byte 5 0285 ICAX6 = IOCB+$0F ; Aux Byte 6 0290 ;0295 .OPT OBJ0300 ;0305 *= $9000 ; Arbitrary. this is relocatable0310 ;0315 INIT0320 LDY #$FF ; Make the return0325 STY ZRET ; value -1 ($FFFF)0330 STY ZRET+1 ; by default.0335 ;0340 PLA ; Get argument count0345 BEQ BYE ; Shortcut for no args.0350 ;0355 TAY0360 ;0365 CMP #$01 ; One arg is not enough.0370 BEQ DISPOSE0375 ;0380 CMP #$03 ; Three args is not supported.0385 BEQ DISPOSE0390 ;0395 CMP #$07 ; More than six is not valid.0400 BCC DO_CHANNEL ; All good. Ready to pull args.0405 ;0410 ; Bad arg count. Clean up for exit.0415 ;0420 DISPOSE ; Any number of arguments0425 PLA0430 PLA0435 DEY0440 BNE DISPOSE0445 RTS ; Abandon ship.0450 ;0455 ; Pull channel and multiply times 160460 ;0465 DO_CHANNEL ; Arg 1 = Channel0470 DEY ; subtract one arg0475 PLA ; discard high byte0480 PLA ; Channel number0485 CMP #$08 ; More than 7 channels0490 BCS DISPOSE ; is invalid.0495 ASL A ; * 20500 ASL A ; * 40505 ASL A ; * 80510 ASL A ; * 160515 TAX0520 ;0525 DO_ICCMD ; Arg 2 = Command0530 PLA ; discard high byte0535 PLA ; command byte0540 STA ICCMD,X ; Store Command in IOCB0545 DEY ; subtract one arg0550 BEQ DO_CIO0555 ;0560 DO_ICBA ; Arg 3 = Buffer Address0565 PLA ; Address high byte0570 STA ICBAH,X0575 PLA ; Address low byte0580 STA ICBAL,X0585 DEY ; subtract one arg 0590 ;0595 DO_ICBL ; Arg 4 = Buffer Length0600 PLA ; Length high byte0605 STA ICBLH,X0610 PLA ; Length low byte0615 STA ICBLL,X0620 DEY ; subtract one arg 0625 BEQ DO_CIO0630 ;0635 DO_ICAX1 ; Arg 5 = Aux Byte 10640 PLA ; discard high byte0645 PLA ; Aux byte0650 STA ICAX1,X ; Store AUX1 in IOCB0655 DEY ; subtract one arg0660 BEQ DO_CIO0665 ;0670 DO_ICAX2 ; Arg 6 = Aux Byte 20675 PLA ; discard high byte0680 PLA ; Aux byte0685 STA ICAX2,X ; Store AUX2 in IOCB0690 DEY ; This should be zero args now...0695 ;0700 DO_CIO ; IOCB is set, now execute...0705 STY ZRET ; Clear return value low0710 STY ZRET+1 ; and high byte.0715 JSR CIOV ; Engage, Mr Crusher.0720 BPL BYE ; No error0725 STY ZRET ; Copy Y to return value0730 ;0735 BYE0740 RTS0745 ;0750 .END The initialization is similar to prior utilities. It begins by setting the return value to a known value ($FFFF) that cannot be returned by a successful exit. Then it pulls the argument count and does a series of value checks to identify any invalid number of arguments. If the code identifies an issue here it branches to cleaning the stack and then exits. One difference in the stack argument management is that this utility does not double the argument count to derive the number of bytes on the stack, because it will not be looping to copy the stack values into Page Zero. The channel handling is more involved than other arguments: 0455 ; Pull channel and multiply times 160460 ;0465 DO_CHANNEL ; Arg 1 = Channel0470 DEY ; subtract one arg0475 PLA ; discard high byte0480 PLA ; Channel number0485 CMP #$08 ; More than 7 channels0490 BCS DISPOSE ; is invalid.0495 ASL A ; * 20500 ASL A ; * 40505 ASL A ; * 80510 ASL A ; * 160515 TAX The channel is pulled from the low byte of the argument. If the value exceeds the range of available channels, then it diverts to the stack cleanup to dispose of the remaining arguments and exits. Recall the earlier discussion about identifying the IOCB for a specific channel -- multiply the channel number times 16 and add to $340. Here the code multiplies the channel number by 16 allowing use of the value as an index to load values into the correct IOCB. The remaining arguments are handled similarly: 0525 DO_ICCMD ; Arg 2 = Command0530 PLA ; discard high byte0535 PLA ; command byte0540 STA ICCMD,X ; Store Command in IOCB0545 DEY ; subtract one arg0550 BEQ DO_CIO The values are pulled from the stack and stored in the corresponding IOCB field. Then the argument counter is decremented. At the end of processing the arguments for command, buffer length, and ICAX1 (arguments 2, 4, and 5) the argument count is tested if it has reached zero. If this occurs then the program skips over the work for processing any subsequent arguments. Finally, it gets down to business: 0700 DO_CIO ; IOCB is set, now execute...0705 STY ZRET ; Clear return value low0710 STY ZRET+1 ; and high byte.0715 JSR CIOV ; Engage, Mr Crusher.0720 BPL BYE ; No error0725 STY ZRET ; Copy Y to return value Recall that the Y register is used to count arguments and by the time the routine reaches this point the Y register is guaranteed to contain zero. So, this is a convenient source to clear the high byte of the return value for BASIC. Next, the code calls the CIO Vector ($E456). When the CIO routine returns the error code is in the Y register and the utility copies that value to the low byte of the return value. Let's go over a couple implications when this is used in BASIC: 1. The function accepts an absolute address and a length allowing access to any part of memory. While this is much more flexible than XIO it also means that this routine cannot directly accept a BASIC string. This routine can use a string passed by its address via ADR(). It is also up to the BASIC program to pass the correct length. LEN() is correct only when the string has defined content, so a BASIC program must fill or pad out the string to its expected length. 2. Since this is a USR() routine it is not integrated in BASIC's error handling. Therefore TRAP cannot trap any Input/Output errors. The BASIC program must check the return value of the NXIO routine or use the STATUS command to identify problems. Testing New XIO Now that we have some experience using files for binary data we're going to start with something different. The Atari BASIC program below, MAKENXIO.BAS, creates a binary file containing the machine language code for the NXIO routine. 1 REM MAKENXIO.BAS5 REM CREATE NXIO.BIN FILE10 OPEN #1,8,0,"H1:NXIO.BIN"15 FOR I=1 TO 9420 READ D:PUT #1,D25 NEXT I30 FOR I=95 TO 25535 PUT #1,040 NEXT I45 CLOSE #150 END21996 REM H1:NXIO.OBJ21997 REM SIZE = 9421998 REM START = 3686421999 REM END = 3695722000 DATA 160,255,132,212,132,213,104,24022001 DATA 84,168,201,1,240,8,201,322002 DATA 240,4,201,7,144,6,104,10422003 DATA 136,208,251,96,136,104,104,20122004 DATA 8,176,243,10,10,10,10,17022005 DATA 104,104,157,66,3,136,240,3422006 DATA 104,157,69,3,104,157,68,322007 DATA 136,104,157,73,3,104,157,7222008 DATA 3,136,240,14,104,104,157,7422009 DATA 3,136,240,6,104,104,157,7522010 DATA 3,136,132,212,132,213,32,8622011 DATA 228,16,2,132,212,9622012 DATA 67,3,133,212,96 This will make managing the utility easier, allowing the test program (and any other BASIC program) to load the utility directly from the file without reading DATA statements. Note that the program purposely pads the output to 255 bytes, so that a BASIC program can use the (broken) XIO command to load the binary data. Next, is the test program that exercises the features of NXIO. It begins by loading the NXIO machine language routine into a string using XIO. This is acceptable for the tightly confined usage here – the program does only one operation to read a file of 255 bytes. The remaining CIO activity in the program is run by the shiny, new NXIO routine: 100 REM TSTNXIO1.BAS105 REM TEST THE NEW XIO USR ROUTINE110 POKE 82,0:GRAPHICS 0115 DIM NXIO$(255):NXIO$(255)=" "120 NXIO=ADR(NXIO$)125 REM READ NXIO FROM FILE130 OPEN #1,4,0,"H1:NXIO.BIN"135 XIO 7,#1,4,0,NXIO$140 CLOSE #1145 REM150 REM TEST THE BAD ARG EXIT155 REM TEST BAD ARGS 0160 ? "TESTING BAD ARGUMENTS..."165 BADARG=USR(NXIO)170 ? "BAD ARGS 0 = ";BADARG175 REM TEST BAD ARGS 1180 BADARG=USR(NXIO,3)185 ? "BAD ARGS 1 = ";BADARG190 REM TEST BAD ARGS 3195 BADARG=USR(NXIO,3,3,32000)200 ? "BAD ARGS 3 = ";BADARG205 REM TEST BAD ARGS 7210 BADARG=USR(NXIO,3,3,32000,2,3,3,3)215 ? "BAD ARGS 7 = ";BADARG220 GOSUB 595225 REM230 REM DO CIO 3/OPEN TO SET UP235 REM A GRAPHICS MODE AND RUN240 REM THE 18/FILL COMMAND.245 REM FORCE "S:" CLOSED250 CLOSE #6255 REM OPEN AS GR MODE 5, NO WINDOW260 GROPEN=USR(NXIO,6,3,ADR("S:"),2,12,5)265 REM SAME AS EARLIER XIO FILL DEMO270 COLOR 3275 PLOT 70,45:DRAWTO 50,10280 DRAWTO 30,10:POSITION 10,45285 POKE 765,3290 XFILL=USR(NXIO,6,18)295 GOSUB 600:REM WAIT FOR A KEY300 REM REPORT THE RESULTS305 GRAPHICS 0310 ? "GROPEN = ";GROPEN315 ? "XFILL = ";XFILL320 GOSUB 595325 REM330 REM GAMES WITH BINARY FILES335 REM LOAD THE 8 BYTE MEMORY FILE340 DIM D$($="!!!!!!!!"345 ? "LOADING 8 BYTE MEMORY.BIN..."350 OPEN #1,4,0,"H1:MEMORYT0.BIN"355 XREAD8=USR(NXIO,1,7,ADR(D$),360 CLOSE #1365 FOR I=1 TO 8370 ? ASC(D$(I,I)),375 NEXT I380 ? "XREAD8 = ";XREAD8385 GOSUB 595390 REM395 REM SAVE THE ROM CHARACTER SET400 CR=57344:REM ROM SET $E000405 ? "SAVING ROM CHARACTER SET..."410 OPEN #1,8,0,"H1:CSET.BIN"415 XSAVE=USR(NXIO,1,11,CR,1024)420 CLOSE #1425 ? "XSAVE = ";XSAVE430 GOSUB 595435 REM440 REM GAMES WITH THE BINARY LOAD445 REM SETUP SCREEN FIRST...450 GRAPHICS 0:POSITION 0,12455 SC=PEEK(88)+256*PEEK(89)460 FOR Y=0 TO 7465 FOR X=0 TO 31470 POKE SC+Y*40+X,Y*32+X475 NEXT X480 NEXT Y485 ? "NORMAL CSET DISPLAYED"490 ? "TO LOAD SOFT SET"495 GOSUB 595500 REM505 REM LOAD THE SOFT SET IN510 REM FLIPPED HALF SETS515 CH=36864:REM SOFT SET $9000520 POKE 756,144525 OPEN #1,4,0,"H1:CSET.BIN"530 CSLOAD1=USR(NXIO,1,7,CH+512,512)535 CSLOAD2=USR(NXIO,1,7,CH,512)540 CLOSE #1545 ? "SWAPPED, SOFT CSET CSET DISPLAYED"550 GOSUB 595555 REM560 REM THE END565 GRAPHICS 0570 ? "CSLOAD1 = ";CSLOAD1575 ? "CSLOAD2 = ";CSLOAD2580 END585 REM590 REM WAIT FOR A KEY595 ? "PRESS A KEY"600 OPEN #1,4,0,"K:"605 POKE 764,255610 GET #1,A615 CLOSE #1620 RETURN The program begins by reading the machine language routine via XIO into a string 255 characters long. Yes, the routine is actually only 94 bytes long, so it wastes a bit of space. Such is life when using XIO. The first round of tests validates the argument management. There is a separate test for each bad argument possibility – 0, 1, 3, and 7 (or greater). Each failure to start results in error code 65535 from NXIO: The next round of tests uses NXIO with all the supported arguments to open a graphics mode 5 display with no text window. Then it draws a shape and uses NXIO to execute the 18/Fill command: After the fill completes press a key to continue and then the program prints the NXIO exit codes for the Graphics Open and the Fill: Press a key again and the program runs the next test which uses 7/Get Characters to read the 8-byte MEMORYT0.BIN file created earlier. After loading the file the program prints the ATASCII codes for the bytes in the string. It should report the values below, and then print the exit code from NXIO for the 8-byte read.: Press a key after this to run the next test. This will use the 11/Put Characters to save the entire 1,024 bytes of the Atari's ROM character set to a file. Then it will print the exit code from the NXIO routine for the operation: Press a key to run the next test. This will prepare the screen to demonstrate loading the character set from the file into memory. The characters are displayed in the internal order. Note the order of the characters. Press a key to continue the test. The program will use 7/Get Characters to load the first 512 bytes from the file into the second 512 bytes of the soft character set in memory, and then it loads the second set of 512 bytes from the file into the first 512 bytes of the soft character set in memory. This effectively swaps the images of the first half of the character set with the second half. Observe the “changed” order of the characters: Finally, press a key to return the display to the normal character set and the program will display the return codes from NXIO for the loading activities and then it ends: The tests all work as expected, especially all the uses of 7/Get Characters and 11/Put Characters. So, there is no problem with CIO. The problem really is that BASIC's XIO command unnecessarily manages the interface to CIO commands. Correct use of the CIO commands is so simple and the behavior XIO implements is so involved and complicated that it is difficult to consider it simply an accident. What could be the reason for XIO's bizarrely over-engineered behavior? Perhaps at the time Atari BASIC was designed there was an expectation that these I/O operations must work in increments no less and no more than 255 bytes. Perhaps a misunderstanding between OS design and BASIC design? Perhaps design requirements were in motion and it was too late to fix the behavior. Truly weird. Below is a list of the source files and test examples from the New XIO discussion available in the disk image and archive. The files are listed in the order presented during the discussion. The BASIC programs come in the tokenized BASIC format ending in .BAS. Two listings in text format are also provided: Atari ATASCII format as .LIS and unix/linux text format ending in .TLS. New XIO File List: MSAVEDAT BASIC program to PRINT eight values to a file. MSAVEDT0 BASIC program to PUT eight bytes to a file. MLOADDT0 BASIC program to GET eight bytes from a file. XIOFILL BASIC program performing the XIO fill command using device “Q:” MSAVEDT2 BASIC program using XIO for 11/Put Bytes to write a file. MSAVEDT3 BASIC program using XIO for 11/Put Bytes to write data to a file with a trailing string to identify the source of excess file data. MLOADDT BASIC program using XIO for 7/Get Bytes. MLOADDTX BASIC program using XIO for 7/Get Bytes with a trailing string to detect excess data read from the file. MSAVE512 BASIC program to generate a file containing 512 bytes. MLOAD512 BASIC program using XIO for 7/Get Bytes attempting to load 512 bytes from a file. MLOAD8 BASIC program using XIO for 7/Get Bytes attempting to load bytes from a file containing 8 bytes. NXIO.M65 Saved Mac/65 source NXIO.L65 Mac/65 source listing NXIO.T65 Mac/65 source listed to H6: (linux) NXIO.ASM Mac/65 assembly listing NXIO.TSM Mac/65 assembly listing to H6: (linux) NXIO.OBJ Mac/65 assembled machine language program (with load segments) NXIO.BIN Assembled machine language program without load segments with additional data padded to the end of the file to make it 255 bytes long. NXIO.DAT LISTed DATA statements for NXIO machine language routine. MAKENXIO BASIC program to create the BIN file with padding to 255 bytes so the file can be loaded using XIO to read the binary data. TSTNXIO1 BASIC program testing the NXIO USR() routines for various CIO commands. ZIP archive of files: NXIO_Disk.zip Tar archive of files (remove the .zip after download) NXIO_Disk.tgz.zip Game Over The movie really is over this time. Thanks for playing. Enjoy the new toys. Finally, welcome to the new world of assembly language. Try to think of new ways to accelerate and improve BASIC programs. - End - Blessed is the man who walks not in the counsel of the wicked, nor stands in the way of sinners, nor sits in the seat of scoffers; Psalm 1:1
  9. DPEEK ============================================================== Part 1 - Introduction http://atariage.com/forums/blog/576/entry-13175-part-1-of-11-simple-assembly-for-atari-basic/ Part 2 - Learn 82.7% of Assembly Language in About Three Pages http://atariage.com/forums/blog/576/entry-13176-part-2-of-11-simple-assembly-for-atari-basic/ Part 3 - The World Inside a USR() Routine http://atariage.com/forums/blog/576/entry-13177-part-3-of-11-simple-assembly-for-atari-basic/ Part 4 - Implement DPEEK() http://atariage.com/forums/blog/576/entry-13178-part-4-of-11-simple-assembly-for-atari-basic/ Part 5 - Implement DPOKE http://atariage.com/forums/blog/576/entry-13180-part-5-of-11-simple-assembly-for-atari-basic/ Part 6 - Various Bit Manipulations http://atariage.com/forums/blog/576/entry-13181-part-6-of-11-simple-assembly-for-atari-basic/ Part 7 - Convert Integer to Hex String http://atariage.com/forums/blog/576/entry-13182-part-7-of-11-simple-assembly-for-atari-basic/ Part 8 - Convert Integer to Bit String http://atariage.com/forums/blog/576/entry-13183-part-8-of-11-simple-assembly-for-atari-basic/ Part 9 - Memory Copy http://atariage.com/forums/blog/576/entry-13184-part-9-of-11-simple-assembly-for-atari-basic/ Part 10 - Binary File I/O Part 1 (XIO is Broken) http://atariage.com/forums/blog/576/entry-13185-part-10-of-11-simple-assembly-for-atari-basic/ Part 11 - Binary File I/O Part 2 (XIO is Broken) http://atariage.com/forums/blog/576/entry-13186-part-11-simple-assembly-for-atari-basic-the-end/ ============================================================== Since one byte can hold the value 0 to 255 a value larger than 255 requires two bytes. The second byte takes the place value 256. Just as Base10 has “ones” values 0 to 9, and then “tens” value for the next position, so the two bytes provide a Base256 value – “ones” value 0 to 255 in the first position and then 256 as the “tens” in the second position. The two-digit value limit for Base10: multiply the maximum base value by 10 for the “tens” value and add the maximum base value of the “ones”, or 9 * 10 + 9 = 99. The same applies for Base256: multiply the maximum base value by 256 for the “tens” and then add the maximum base value as the “ones”, or 255 * 256 + 255 == 65,535. (Or, in hex this is $FF * $100 + $FF == $FFFF.) So, the real value limit of 16-bits starts at 0 and ends at 65,535 or $FFFF. The 64K address space of an 8-bit computer is described by a 16-bit value. So, the Atari environment is liberally sprinkled with 16-bit values as addresses, pointers, and larger integer values. Manipulating 16-bit values is complementary to working in the Atari computing environment, but Atari BASIC does not provide a direct and easy method for this. OSS BASIC XL provides the Dpeek() function to perform a 16-bit, two-byte PEEK of the value at a specified memory location. This can also be duplicated in regular Atari BASIC, although slower. In BASIC XL the action: Value = Dpeek( Address ) is frequently seen in Atari BASIC programs expressed as: VALUE = PEEK( ADDRESS ) + 256 * PEEK( ADDRESS + 1 ) That’s not very complicated. A little programming grease mixed with Atari BASIC’s ability to GOSUB to a variable produces this reusable subroutine: 10 DPEEK=2800020 ADDRESS=560:GOSUB DPEEK30 ? "DPEEK(560)= ";VALUE40 END. . .27997 REM IMPLEMENT DPEEK27998 REM INPUT = ADDRESS27999 REM OUTPUT = VALUE28000 VALUE=PEEK(ADDRESS)+256*PEEK(ADDRESS+1)28001 RETURN The routine is simple; just one real line of BASIC code. But, execution in Atari BASIC is fairly slow, since it includes a floating point multiplication. Infrequent slothfulness is forgivable, but repeated use causes obvious performance drag. What this problem needs is a little assembly language propulsion... DPEEK Mac/65 Assembler Code 0100 ; DPEEK0105 ;0110 ; Return the 16-bit contents0115 ; at the specified address.0120 ;0125 ; USR 1 arguments:0130 ; Addr == address of value.0135 ;0140 ; USR return value is 16-bit0145 ; contents of address. 0150 ;0155 ; Use the FR0 FP register.0160 ; The return value for BASIC0165 ; goes in FR0.0170 ; No FP is used so all of FR00175 ; (and more FP registers) can0180 ; be considered available.0185 ;0190 ZRET = $D4 ; FR0 $D4/$D5 Return value0195 ZARGS = $D5 ; $D6-1 for arg Pulldown loop0200 ZADDR = $D6 ; FR0 $D6/$D7 Address0205 ;0210 .OPT OBJ0215 ;0220 ; Arbitrary. This is relocatable.0225 ;0230 *= $97000235 ;0240 INIT0245 PLA ; argument count0250 TAY0255 BEQ EXIT_ERR ; shortcut for no args0260 ASL A ; now number of bytes0265 TAY0270 CMP #$02 ; Address0275 BEQ PULLDOWN0280 ;0285 ; Bad args. Clean up for exit.0290 ;0295 DISPOSE ; any number of args0300 PLA0305 DEY0310 BNE DISPOSE0315 ;0320 EXIT_ERR ; return "error"0325 STY ZRET ; Y is Zero0330 STY ZRET+1 ;0335 RTS ; bye.0340 ;0345 ; This code works the same0350 ; for 1, 4, 8 ... arguments.0355 ;0360 PULLDOWN0365 PLA0370 STA ZARGS,Y0375 DEY0380 BNE PULLDOWN0385 ;0390 ; Y is already zero here.0395 ;0400 LDA (ZADDR),Y0405 STA ZRET0410 INY0415 LDA (ZADDR),Y0420 STA ZRET+10425 ;0430 RTS ; bye.0435 ;0440 .END In this first example I’ll walk through all the setup and safety checks. This will be similar for most of the other utilities. Some programmers would consider that there is much more code here than required. The safety checks look like overkill, because the working code for this particular utility is so short. Protecting the BASIC programmer from torpedoing the system is important enough to justify protection. From the point of view of execution timing this overhead is inconsequential compared to the speed of BASIC. First of all, the routine is relocatable which means the code makes no absolute references to locations within itself. All branches are relative to the current location, so the code could execute from almost anywhere in memory. However, it does need a couple of fixed locations for working values in the program: 0155 ; Use the FR0 FP register.0160 ; The return value for BASIC0165 ; goes in FR0.0170 ; No FP is used so all of FR00175 ; (and more FP registers) can0180 ; be considered available.0185 ;0190 ZRET = $D4 ; FR0 $D4/$D5 Return value0195 ZARGS = $D5 ; $D6-1 for arg Pulldown loop0200 ZADDR = $D6 ; FR0 $D6/$D7 Address The program needs two values – the address from which to PEEK the 16-bit value, and a place to put the 16-bit value for BASIC to reference. Specifically, the code is using the Page Zero locations. “Page Zero” means all the address locations where the high byte of the address is $00. (The 256 locations from address $0000 to $00FF). Page Zero locations are chosen for several reasons: 6502 instructions referencing Page Zero are one byte shorter and usually execute faster than instructions referencing other pages. The 6502 has useful addressing modes that only work for Page Zero references. BASIC already defines a place in Page Zero for the value the machine language routine returns to BASIC. Since Page Zero locations are so useful they are also highly contested. The Atari OS defines and uses just about every byte in the first half of Page Zero. BASIC and the Floating Point routines use almost all of the second half of Page Zero. As it turns out the locations used by this machine language routine are “claimed” by the Floating Point routines. However, as long as the machine language routine does not need to use the Floating Point routines then these locations are free for use. Now to the working code. The routine begins by pulling the argument count from the stack and checking for zero arguments. If it finds no arguments to process then the routine branches to another location for an early exit. Yes, the TAY instruction is not needed to correctly branch for no arguments. The PLA instruction sets the zero flag when the argument count popped from the stack is zero. However, the exit code will use the Y register to return an error value (which is zero) to BASIC: 0240 INIT0245 PLA ; argument count0250 TAY0255 BEQ EXIT_ERR ; shortcut for no args Next, the routine converts the number of arguments into the number of bytes to pull from the stack. It uses ASL which is the same as multiplying the value in the Accumulator times two. This is stored in the Y register which is used as an index for later loops. The routine verifies the argument count is correct (only 1 argument – the address to PEEK) which is 2 bytes. If this is correct the routine branches to the code that will pull the stack values and place them in Zero page memory for use later: 0260 ASL A ; now number of bytes0265 TAY0270 CMP #$02 ; Address0275 BEQ PULLDOWN If the argument count is incorrect then the routine discards the argument values on the stack, so it can safely exit. Remember the Y register already contains the number of argument bytes on the stack: 0295 DISPOSE ; any number of args0300 PLA0305 DEY0310 BNE DISPOSE Next, the routine falls into the exit section. Earlier, if there were no arguments the routine branched here directly. Note that if there are no arguments the Y register contained 0 when it branched here directly, and at the conclusion of cleaning up the stack in the DISPOSE loop the Y register will also be 0. So, in either case of bad arguments, too many or too few, the return value to BASIC is cleared to 0: 0320 EXIT_ERR ; return "error"0325 STY ZRET ; Y is Zero0330 STY ZRET+1 ;0335 RTS ; bye. Clearing the return value really isn’t necessary and isn’t exceedingly useful beyond insuring random values are not returned to BASIC in the case of an error. Returning a real error would require the USR() pass another argument from BASIC that the routine would use to indicate success or failure. However, the DPEEK action is so simple that this level of error detection begins to enter the arena of silly. The error detection shown here already leans toward overkill and is done for design consistency with the other utilities covered later. At this point the arguments are correct. The routine pulls the values from the stack and places them in Page Zero locations $D6/$D7 referred to as ZADDR. On entry to this point in the code the Y register contains the number of bytes to pull from the stack (always 2 for this routine). The loop pulls them off the stack and places them into memory descending as it goes, because the high byte is pulled first, then the low byte. The base address is not ZADDR, but ZARGS, a value defined one byte less than ZADDR. This is because the Y value will be used as an index from the number of argument bytes (2, 4, 6, etc.) counting down to 1, not to 0. Counting backwards results in the stack values placed in memory in the correct low byte, high byte order used by the 6502. When Y reaches 0 it falls out of the loop: 0360 PULLDOWN0365 PLA0370 STA ZARGS,Y0375 DEY0380 BNE PULLDOWN This code works for any number of arguments as long as the destination can be sequential bytes in memory. However, this is admittedly overkill for only one argument. More explicit code that directly pulls one 16-bit argument from the stack requires the same number of instructions, but is one byte less (and executes faster). Just for reference: 0360 PULLDOWN0365 PLA0370 STA ZADDR+1 ; high byte first.0375 PLA0380 STA ZADDR ; low byte next. The actual work to perform the double byte peek is just the five instructions before the final RTS. The routine reads two bytes through the address contained in ZADDR ($D6/$D7) and copies the bytes to the return value, ZRET ($D4/$D5): 0400 LDA (ZADDR),Y0405 STA ZRET0410 INY0415 LDA (ZADDR),Y0420 STA ZRET+1 After the routine exits Atari BASIC converts the value stored in locations $D4/$D5 (ZRET in the code) into a floating point value. This becomes the return value from USR(). So, in the following BASIC statement the variable X is assigned the value taken from $D4/$D5: 250 X=USR(DPEEK,560): REM DISPLAY LIST ADDRESS Below are source files and examples of how to load the machine language routine into BASIC included in the disk image and archive: DPEEK File List: DPEEK.M65 Saved Mac/65 source DPEEK.L65 Mac/65 source listing DPEEK.T65 Mac/65 source listed to H6: (linux) DPEEK.ASM Mac/65 assembly listing DPEEK.TSM Mac/65 assembly listing to H6: (linux) DPEEK.OBJ Mac/65 assembled machine language program (with load segments) DPEEK.BIN Assembled machine language program without load segments MKDPEEK.BAS BASIC program to create the DPEEK.BIN file. This also contains the DPEEK routine in DATA statements. MKDPEEK.LIS LISTed version of MKDPEEK.BAS MKDPEEK.TLS LISTed version of MKDPEEK.BAS to H6: (linux) DPEEK.BAS BASIC program that loads DATA statements into a string. DPEEK.LIS LISTed version of DPEEK.BAS DPEEK.TLS LISTed version of DPEEK.BAS to H6: (linux) The next task should be a test program to demonstrate using DPEEK in BASIC. But, since DPEEK isn’t much use without DPOKE, we will visit DPOKE first before using the machine language routines together in a BASIC program. ZIP archive of files: Dpeek_Disk.zip Tar archive of files (remove the .zip after download) Dpeek_Disk.tgz.zip Therefore I tell you, do not be anxious about your life, what you will eat or what you will drink, nor about your body, what you will put on. Is not life more than food, and the body more than clothing? Look at the birds of the air: they neither sow nor reap nor gather into barns, and yet your heavenly Father feeds them. Are you not of more value than they? And which of you by being anxious can add a single hour to his span of life? And why are you anxious about clothing? Consider the lilies of the field, how they grow: they neither toil nor spin, yet I tell you, even Solomon in all his glory was not arrayed like one of these. Matthew 6:25-34
  10. I am asking $150 plus shipping for a CIB XEGS Console Keyboard Original joystick Light gun (label peeling off one side) Power Supply RF Cable Switchbox RCA cable Flight Simulator II Bug Hunt Booklets Styrofoam inserts Original box SOLD
  11. I am looking for an Atari 820 printer in working condition. PM me if you have one.
  12. Link to pictures below Need help identifying this stuff, I own a small retro store in Dracut, Ma called Bazaar Game Trading (Facebook.com/bazaargametrading) and being the only retro gaming store in the area that takes anything pre nes, I am seeming to run into a lot of really really cool stuff. I got an atari 400/800/xl/xe lot in recently, most CIB, most including ALL inserts, most having pristine beautiful labels, and I'm seeming to only find loose cart copies circulating for a lot of these. so, 1. anyone know what these are worth? These are here because it's hard to find reliable salse data on them within the past 90 days from ebay, amazon, half.com etc. So, I've already done all that =] 2. How rare are these titles in this condition exactly? I am at heart a collector, I love what I work with so I am tempted to keep stuff all the time ; ;. 3. I have people who are wanting them but I need to find a price for them that's fair for me, and them. So I told them I had to do research here to find out what's fair. Thanks everyone! Message me by reply, private message, email- [email protected], or facebook message at facebook.com/bazaargametrading My pictures are uploaded on flickr. https://www.flickr.com/photos/[email protected]/with/15471969531/
  13. Hey fellow 2600 enthusiasts, On Saturday, June 14, 2014, the free-to-the-public Sunnyvale Atari Party will take place at the Sunnyvale Public Library from 10:00 am - 4:00 pm. Please come and join Bill Kendrick and the rest of us there. There will be Atari 2600s/Flashbacks, 5200s, 7800s, XE Game System, Lynxes, Jaguars, arcade machines, Atari 8-bit computers, Atari STs, and modern PCs emulating the classic consoles. In addition, we are fortunate enough to have two legendary ex-Atari employees who will be speaking. The first is Al Alcorn, Atari employee #3, builder of Pong, who worked on the Atari 2600, Atari's holographics, and countless other items. He later became an Apple Fellow*. And then there's Dan "The TrakBall Man" Kramer who is personally responsible for the 2600 and 5200 TrakBall Controllers, amongst many other projects during his time at Atari Inc. He is also promising to show off some prototype hardware as well. http://www.newbreeds...tariparty/2014/ Sunnyvale CA is, of course, Atari's old hometown. Please visit the website link above for more details. Volunteers are also welcome. This is a kid-friendly event so bring the whole family... *If you've watched the recent Steve Jobs film [Jobs], Mr. Alcorn is represented in the film. He's referred to as "Al" during the Atari scenes and "he" is the one who informs Jobs that he's "an a$$hole".
  14. I have a whole bunch of games I don't want any more. Perhaps you do? United States only, all are NTSC games. PM me. I'll try to respond to all when I can first come first served and I'll try to update and remove things that have been sold. All the games are loose except where noted. atari 2600 game lot all these for $5 asteroids championship soccer - missing end label dodge 'em home run missile command othello realsports baseball x2 street racer surround target fun video chess Atari 800 games ($5 each): asteroids defender dig-dug donkey kong jr. (pending) frogger (pending) galaxian (pending) joust missile command pac-man pole position space invaders super breakout Atari 5200 (note: I don't have a 5200 to test these on, so as is.) all 3 for $7.50 galaxian pac-man super breakout CD-i $5 each compton's interactive encyclopedia defender of the crown jigsaw laser lords mystic midway - rest in pieces pinball treasures of the smithsonian video speedway NES CIB games snake rattle & roll - $10 loose games alfred chicken - $15 (pending) al unser jr. turbo racing - $2.50 excitebike - $2.50 (pending) millipede - $2.50 (pending) rolling thunder - $5 xevious (yes i have a loose one too.) - $2.50 saturn (all have boxes except mr. bones. some of the boxes have a crack or two, you know, saturn and all.) $5 daytona usa frank thomas madden 97 madden 98 minnesota fats nba live 98 $10 amok black fire croc grid runner last gladiators pinball machine head mr. bones myst robotica tetris plus wipeout wii-u Sonic All stars racing - $20 Nintendo Land - $15
  15. I am working on a project (still working out some display and register issues) when it dawned on me. The original 400/800 had four controller ports and each port, in simple terms, had its own player register in PM Graphics (or in the OS). XL and XE machines removed two of the controller ports I assume to cut production costs. Does this mean that the extra player registers were removed as well or are they still intact? I'm asking because my game project is designed on paper to take advantage of all four player registers. I don't want to create something for just a specific line of Atari 8-bits...I want it to be able to play on all of them. Thanks in advance!
  16. FOR SALE: Atari 8-Bit List Various 8-bit kit for sale: Offers please: Buyer also pays postage but can choose which category/rate by which items will be dispatched. Will also accept collection buyers. There's a quite a bit here, so have a browse and let me know and reply below or at: [email protected] Atari 1029 Printer : No Box - powers up, print head seeks, no SIO. Atari 1027 Printer : No Box - powers up, print head seeks, no SIO. Atari 1020 Printer/Plotter : CIB . Atari Touch Tablet : sale pending CIB. KoalaPad Touch Tablet : CIB. Various Atari 8-bit Cartridges : £10 each Loose carts. Atari 400/800 Programming Language PILOT with "Turtle Graphics" : Complete. Atari 850 interface : sale pending No Box - powers up, no SIO or power lead. Atari Track & Field Controller : No Box. Atari Turbo Basic/Turbo Compiler XL/XE : Complete. Ultimate 1mb (Candle 'o' Sin) XL upgrades : sold Not sure if these are complete or working as never fitted - see pics.
  17. Complete Atari set for retro gaming all items are NEW and UNUSED ATARI 130XE, PAL, NEW, unopened box SDrive NUXX NEW, never used IDE plus 2.0 host adapter NEW never used 2x Atari XE (65/800/130) keyboard NEW, unused Scart cable only once used professionally made (maybe 2 pcs) price 390,-€ for complete set
  18. Updated to reflect status of one unreliable Indus drive after testing it out. Also dug out the Jaguar unit and noticed that switchbox was nowhere to be found, so removed CIB from the description. I've decided to unload my Atari video game and 8-bit computer collection. I'll try to get a full list together soon. Computer collection highlights: 800XL computer Indus GT drives (2 drives; one in fair conditionnot to be trusted, the other in good condition with plastic storage case and the original software) 1050 drive in box (Happy enhanced) APE For Windows Complete Starter Kit USB Games by Atari, Infocom, Epyx, EA (much of it CIB) Misc cables, software, peripherals Video game collection highlights: Boxed consoles (Jaguar w/ CD, 7800) Loose consoles (2600, 5200, Lynx, Telegames II) Some CIB 2600 and 5200 games Controllers for each console system 2600 cartridge adapter for 5200 I haven't used most of these items for years, but they've been stored indoors out of the way. Now they're in the way. Anyone in the Phoenix area is welcome to schedule a time to stop by and check things out. (That would also be the quickest way to take home a huge bargain.) Meanwhile I'll do my best to get a more detailed list ready with condition and prices. Pricing will be fair, as my motivation to unload the collection is more about to time than money. Hope this is enough info in the initial post. I'm trying to gauge interest without spamming the group.
  19. UPDATE: The final version can be found here! Donkey Kong was one of my childhood favorite games. I have always loved the attention to detail in the Atari Computer port. The gameplay is smooth, and it include more game nuances than other conversions of the time. I always thought that Mario and Donkey Kong could have looked a little better. I actually thought Pauline looked BETTER than the arcade. (I did make her more arcade-like in this hack, because I am going for arcade closeness.) After I dug into the game, I found even more appreciation for the A8 version. The memory-saving techniques that Landon used were great. His software sprite routine is terrific. These techniques allowed him to fit SO MUCH into 16K. They did come with a price. Donkey Kong is a mirror image, which means that there are some sacrifices that need to be made. In order to keep Kong's eyes only 1-pixel apart, his mouth is a little off-center in one of the chest-beating frames. Drawing the software sprites on screen seems to mean one less color than a "tile/character" mode. That means no white teeth or eyes for Kong. However, the smoothness at which the software sprites move make it totally worth it. So, in the end, I am trying to make some tweaks, using the advantage of modern day tools. Mario will be the toughest. Mario's made up of 3 player/sprites: red, flesh, and blue. The blue player seems to always be 1-pixel behind the other two. I would really prefer to get rid of that, because it is going to create issues for some of the frames. At this point, I have tweaked most of the playfield objects (Kong, Pauline, Girders, Oil Can, Still Hammers, Fireballs, Pies, etc.). The only player (sprite) I have touched is Mario, and I have only replace ONE of his frames at this point. Pauline's items are also a player. I am sure, as with JR, this will evolve. Original Update Updated Screens:
  20. Atari 600xl Chips for Sale C014795 $11.99 C012296 $10.99 C014806 $10.99 C014805 $11.99 All chips have been tested and are working. I have several of each chip. US shipping would be $2.70 plus $0.10 per chip. International shipping is $5.70 plus $0.70 per chip. PM me with which chips you need and how many as well as the shipping address and I will send an invoice through paypal. I will also consider any reasonable trade offers of atari 2600 games or original Commodore software.
  21. I have a very nice collection of hardware and software for Commodore, Amiga, Atari, and Apple for sale. You can see a list of the highlights at: http://1drv.ms/1Ef5TRn A list of things you may be interested in: Flat 128 w/JiffyDOS and 64K Video Upgrade 1541 Ultimate Gen 1 w/Ethernet 2x EasyFlash 3 1764 w/512K MSSIAH RA Thunderdrive 4GB CMD RamLink (needs love) Apple IIgs w/2MB Focus IDE+CF 3.5 Unidisk 5.25 Drive for IIgs Apple //c+ Apple //c w/Power Supply A2000 w/80GB SSD (SCSI to SATA adapter) 68030/30 w/16MB of RAM SCSI CD-ROM Commodore 2002 Monitor Parallel IP Link Hundreds of disks Many originals I WILL NOT part up the collection. It's all or nothing. Bring a U-Haul, you're gonna need it. $2000 or best offer.
  22. Hi All, I am looking for a Key to replace my Start Key on my 800XL which is worn (see below) I have an 800XL I use for parts but discovered that the keys between models are different (See below) The key I want to replace has a "plus" config, however the one on my parts machine has a "Slit" config. Unfortunately I can't swap the whole key unit between machines as some of the keys on the broken XL are damaged. If anyone has a spare scratch and dent free key in the "Plus"config then I would be interested in getting hold of it Cheers Rel
  23. I've acquired some Atari 8-bit diskette sets. I thought since I collect mainly cartridges I'd see who might be interested in some of these. The prize of the collection is the Infocom Suspended "Masked" version. These have been untouched for 25 years. This is the one of the best copies I have seen. I don't think it was used. Please PM me if you're interested in it. I would love to trade for A8 cartridges if possible.
  24. I have this GTIA chip for sell, it is correct, no defective... I am asking 7€ + shipping + paypal f. thanks
  25. Price Drop! $225 shipped. $175 shipped. Will also consider trades for a Vectrex or Virtual Boy. Atari 8 bit collection. I hate to sell it but I never really use it and need room for more stuff. Everything was tested just before I posted this. 800XL and 1050 drive works great. 25 floppy disks, all tested and work great and 15 cartridges. A bunch of great games included. Floppy Disks: Bop'n Wrestle Broadsides Cosmic Balance II Napoleon at Waterloo Combat Leader Silent Service Ace of Aces Conflict in Vietnam Xlent Wordprocessor Computer Quarterback Panzer Grenadier Flight Simulator II Flight Simulator II Scenery Disk NATO Commander Kick Start Off Road Simulator Beach-Head Infiltrator Sargon II Dr. Seuss Fix-Up the Mix-Up Puzzler World Karate Championship Star League Baseball Super Huey Hard Hat Mack Speed King Star Fleet I Cartridges: River Raid Return of the Jedi Pitfall II Jungle Hunt - missing front label Bug Hunt Defender Centipede Space Invaders HardBall! Basketball Pole Position Middle Command Basic
×
×
  • Create New...