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
  • Arcade Gaming's Discussion
  • Tesla's Vehicles
  • Tesla's Solar
  • Tesla's PowerWall
  • Tesla's General
  • Harmony/Melody's CDFJ
  • Harmony/Melody's DPC+
  • Harmony/Melody's BUS
  • 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
  • Atari Lynx 30th Birthday's 30th Birthday Programming Competition Games
  • 3D Printing Club's Chat
  • Drivers' Club's Members' Vehicles
  • Drivers' Club's Drives & Events
  • Drivers' Club's Wrenching
  • Drivers' Club's Found in the Wild
  • Drivers' Club's General Discussion
  • Dirtarians's General Discussion
  • Dirtarians's Members' Rigs
  • Dirtarians's Trail Runs & Reports
  • Dirtarians's Wrenching
  • The Green Herb's Discussions
  • Robin Gravel's new blog's My blog
  • Atari Video Club's Harmony Games
  • Atari Video Club's The Atari Gamer
  • Atari Video Club's Video Game Summit
  • Atari Video Club's Discsuuions
  • Star Wars - The Original Trilogy's Star Wars Talk

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 114 results

  1. 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
  2. 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:
  3. 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
  4. 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
  5. 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
  6. 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
  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. 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.
  9. 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.
  10. 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.
  11. 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
  12. I am looking for an Atari 820 printer in working condition. PM me if you have one.
  13. 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/
  14. 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
  15. 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.
  16. 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!
  17. 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
  18. 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".
  19. 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.
  20. Simple Assembly for Atari BASIC A multi-part discussion of a few pet peeves about Atari BASIC and simple machine language utilities to fill in the gaps. July 2016 ============================================================== 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/ ============================================================== This actually isn't the project I meant to be working on. I ended up here, because of a series of other needs. Originally, I was working on converting some old examples from Compute! not written for the Atari and needed to demonstrate a machine language sort for an Atari BASIC numeric array. This required I understand Atari BASIC variables, and while writing that discussion I realized I needed facilities not included in Atari BASIC (16-bit peek and poke, memory moves, etc.) So, that brought me here to fill in some gaps missing in Atari BASIC. Now that I'm done with this hopefully the Atari BASIC Variable article will be done soon, then I can get back to the machine language sort. it will take a while to get these articles posted, reformatted, etc. Several will be posted today, and others over the next few days. For those who don't care to wait for the multi-part bloggitty-blog version the complete document is attached below in a couple formats: LibreOffice ODT. Remove the .zip after downloading: HelpBASIC.odt.zip PDF version: HelpBASIC.pdf ============================================================== Introduction: The Good… The Atari 8-bit computer was a paradigm-changing platform when introduced in 1979. The extensive, built-in color graphics and sound capabilities started computer-based “multimedia” years before the word existed. Atari would have been justified keeping it a completely closed box of mystery. Fortunately, they did not. Atari provided a BASIC language with reasonable support for the computer’s custom hardware graphics and sound features. Many other computers introduced before and even after the Atari had BASIC languages providing little to no support for graphics or sound. They were little different from the original BASIC (circa 1964) developed in an era of time-sharing terminal printers intended for number and text processing. Atari BASIC incorporates some good ideas. On program entry Atari BASIC converts commands to an abbreviated form called tokens. Using tokens cuts down memory use for program storage, speeds up program execution, and the tokenization process provides immediate syntax error feedback at the time a programmer enters a program statement. Atari BASIC provides exceptionally high readability compared to other BASICs of the day. Atari BASIC nicely inserts spaces between commands and values in program listings. This spacing does not occupy the program's memory thanks to tokenization. Finally, Atari BASIC recognizes long variable names enhancing readability. Some do not like the way strings work in Atari BASIC, but I find they make a lot of sense. When moving on to C years later, I credit the reduced learning curve for C strings to Atari BASIC; the way an Atari string behaves in memory is more like a C array of characters (less the ‘\0’ terminator) than Microsoft BASIC strings. Also, a character pointer in C is a concept similar to the Atari BASIC ADR() function. The Bad… Of course, nothing is perfect. Atari BASIC is missing some useful features for dealing with computer hardware on the computer’s terms. This is not really a critical failure of Atari BASIC, since many other BASICs do even less than Atari BASIC and part of the purpose of original BASIC was to protect the beginner programmer from architectural questions about the computer hardware. But, given the Atari’s additional graphics and sound features part of the fun of programming is making the Atari hardware do interesting things. 8-bit computers frequently have reason to deal with 16-bit, two-byte values. While Atari BASIC has PEEK and POKE working with single-byte values it lacks a way to work directly with two-byte values. The Atari hardware provides many interesting bells and whistles for graphics and sound. (Literally, it can make bell and whistle sound effects.) Effective interaction with hardware registers and the operating system often require manipulating individual bits within a byte. Bit operations are not available in Atari BASIC. Hand-in-hand with 16-bit values and bit operations is working with hexadecimal representation of values. When one becomes familiar with the hardware it begins to make a lot more sense to refer to and display values in their hexadecimal form. Hexadecimal value representation is not included in Atari BASIC. Moving blocks of memory around has many practical uses in the Atari environment – copying character sets, animating characters or Player/Missile graphics, rapid updates of color registers, etc. Atari BASIC does not have a general purpose memory move feature. There is a common hack using Atari BASIC strings to perform a high-speed memory move. However, this method requires more setup, is not obvious to the casual programmer, and so is not as convenient and flexible as a command to move memory. Atari BASIC’s I/O functions are missing the ability to load bulk, binary data into memory from a file, (such as graphics or character sets.) Atari BASIC must use slower loops to read a file, or waste memory by including the data within the BASIC program. And the Ugly (or just darned weird)… The worst weird thing about Atari BASIC does is that it handles all numbers as 6-byte, BCD, floating point. In spite of this it is still comparatively fast, so it makes one wonder how fast Atari BASIC could be if it used 16-bit integers instead of bogging down the 1.79 Mhz CPU with floating point math. Another problem built into Atari BASIC is line lookup for statements. Atari BASIC identifies statements during execution by searching the line numbers from the beginning of the program to the desired statement. This causes statements at the end of a long program to execute slower than statements near the start of the program. Atari BASIC has two different syntax options for GOTO. These are both valid: 100 GOTO 10 200 GO TO 150 What's up with that? It is a joke, right? I do hope the implementation cost less than a dozen bytes. Couldn't this have been replaced with a solution to one of the other problems, such as 16-bit PEEK and POKE? All these issues with floating point use, line searching, and command syntax are fundamental to the internals of Atari BASIC, so solutions to these situations require writing a new version of BASIC. Since I’m not planning on making a career of this, contentment will have to come from resolving the easier problems mentioned earlier. The Solution To fix these problems get a copy of OSS BASIC XL or BASIC XE, or TurboBasic XL. Really. Seriously. These BASICs can load and run all Atari BASIC tokenized programs (that is, SAVE’d programs) and ENTER Atari BASIC LIST’ed programs correctly at least 98% of the time. Both are faster than Atari BASIC and provide many of the useful features discussed here. And with the advent of high quality emulators you don't even need to concern yourself with acquiring the languages on physical ROM cartridges or disks. You can get the whole Atari experience plus modern convenience just by downloading a few digital image files. So, problem solved. Thanks for reading. See you later. The Other Solutions You're still here? The movie is over. Go home. . . . So, trading up to a better BASIC is out of the question? For whatever questionable reason you are actually married to Atari BASIC and can’t switch to anything else? Fine. (Do not send me pictures of your children.) If there were no other options the article would end here. However, the miles of text (in the half dozen subsequent parts) must indicate interesting stuff follows. Most of the issues are less difficult than they appear. In some cases a simple solution can be written using just Atari BASIC. However, given the speed of Atari BASIC the real problem becomes how to do it fast enough to be worthwhile. The best performance comes from machine language code. Even badly written assembly will produce machine code that runs circles around Atari BASIC. Below, the article will demonstrate that it has more than enough badly written assembly code to go around for everyone. This article presents several reusable machine language utility programs expanding BASIC programs’ capabilities, and improving performance. These utilities are designed to be called from BASIC’s USR() function. This article is not entirely a lecture on learning 6502 programming from scratch. But, the solutions are not terribly complicated, so it should not be too difficult for a beginner to follow. Final solutions with the utilities implemented in Atari BASIC test programs will appear for those who don't care about the assembly code. Next time we will learn about Assembly language syntax and instructions in as few pages as possible. For I know the plans I have for you, declares the Lord, plans for welfare and not for evil, to give you a future and a hope. Jeremiah 29:11
  21. Been a while since I attempted this, and perhaps I'm getting Atari 8 and 16 bit machines a bit confused, but I remember writing a utility back in the day that moved the screen around memory. One interesting thing was that if the pointer to screen memory was placed just before or just after the start of actual screen memory, there would be a neat artifact like 1-dimensional video feeback, where one line would get duplicated, then that would get duplicated, etc. It looked like a faux 3d perspective effect where the "closer" objects would be taller. I found From Compute's Second Book of Atari Graphics, Program two, here: http://www.atariarchives.org/c2bag/page185.php to move screen memory around, but it's not behaving how I'd like. I have a feeling it's limited to a specific region of memory. I started with it, modified to use graphics 9. It does move the screen through memory using the arrow keys, but does not exhibit the powers-of-two one-dimensional video feedback I remember. Perhaps it's not crossing the screen boundaries in the way I remember? Modified listing using basic mode 9: 5 GRAPHICS 9 10 REM COARSE VERTICAL SCROLLING DEMO 15 REM PRESS UP/DOWN ARROWS TO MOVE DISPLAY THRU MEMORY 20 DLIST=PEEK(560)+PEEK(561)*256:REM GET START OF DISPLAY LIST 30 LMSL=DLIST+4:REM POINTER TO DISPLAY MEMORY 40 LMSH=DLIST+5 50 DISPLAYL=0:REM INITIALIZE ADDRESS OF DISPLAY MEMORY 55 REM READ KEYBOARD 60 IF PEEK(764)=255 THEN GOTO 60:REM WAIT FOR KEY 70 IF PEEK(764)=14 THEN POKE 764,255:GOTO 110:REM UP ARROW / 80 IF PEEK(764)=15 THEN POKE 764,255:GOTO 140:REM DOWN ARROW ? 90 GOTO 60 100 REM MOVE DISPLAY WINDOW INTO LOWER MEMORY 110 DISPLAYL=DISPLAYL-40 120 IF DISPLAYL>=0 THEN GOTO 170:REM CAN'T DISPLAY NEGATIVE MEMORY 122 DISPLAYH=DISPLAYH-1:DISPLAYL=0 124 IF DISPLAYH<0 THEN DISPLAYH=0 126 GOTO 170 130 REM MOVE DISPLAY WINDOW INTO HIGHER MEMORY 140 DISPLAYL=DISPLAYL+40 150 IF DISPLAYL>240 THEN DISPLAYH=DISPLAYH+1:DISPLAYL=0 160 REM CHANGE DISPLAY MEMORY POINTER 170 POKE LMSL,DISPLAYL:REM PUT NEW DIPLAY ADDR IN DISPLAY LIST 180 POKE LMSH,DISPLAYH 200 GOTO 60:REM GO WAIT FOR KEYBOARD ENTRY The eventual goal is to have a split screen using display lists, having a static mode 11 top—rainbow sky—and a "scrolling" (by changing memory that then propagates down the feedback loop) bottom section in mode 9—ground. The features on the ground should ideally be bits from memory (to simplify my landscape drawing code P189L2.bas.txt
  22. I've been working with DLI's on the Atari 8-bit/5200 - a fascinating and powerful technology for doing really cool things with the display! I have decided to add them to the next release of Virtual World BASIC for the 2600! Here's a BASIC Display List Interrupt Demo for the Atari 2600, the program listing and the DLI chapter from the manual to discuss. DLI_Demo4.bin Display_List_Interrupt_demo4.txt The BASIC DLI demo is only 20 lines of code, easy to review (I reused code from 9LineBlitz). Note: This DLI code won't compile until the next version of vwB is released (soon, along with other enhancements). Draft of the new chapter on DLI's: Display List Interrupts ------------------------------- Display list interrupts run during the vertical blank and provide the ability to split the screen up into multiple horizontal sections, each of which can contain a vertically, horizontally or diagonally scrolling playfield with free floating or tile-mapped sprites. The DLI demo program (DLI_Demo.txt) demonstrates setting up display lists to scroll the top half of the screen vertically while scrolling the bottom half of the screen horizontally at different speeds. The demo actually uses 4 DLI calls to do this but arranges them to create two contiguous scroll zones. Syntax for calling the DLI is simple: "gosub DLI" two rows (1/5) of the screen will be updated based on the value you store in scrollvirtualworldtoggle (it's reused for DLI's; just don't use zero). Put in an 8, and the bottom two rows of the screen will be updated: 100 scrollvirtualworldtoggle=8:gosub DLI:scrollvirtualworldtoggle=0: rem call DLI, update tile rows 9 and 10. Put in a 1 and rows 2 and 3 will be updated near the top of the screen: 100 scrollvirtualworldtoggle=1:gosub DLI:scrollvirtualworldtoggle=0: rem call DLI, update tile rows 2 and 3. Trick to span three rows (about 1/3 of the screen) - use "3" as a prefix before the start row. Put in a 37 and the bottom three rows of the screen will be updated: 100 scrollvirtualworldtoggle=37:gosub DLI:scrollvirtualworldtoggle=0: rem call DLI, update tile rows 8,9 and 10. Put in a 30 and the top 3 rows will be updated. 100 scrollvirtualworldtoggle=30:gosub DLI:scrollvirtualworldtoggle=0: rem call DLI, update tile rows 1,2 and 3. It's no more complex than setting the x,y coordinates for the playfield camera to pan the view about the virtual world, you're just able to do that independantly for each section of the screen you define with a DLI! You can call a DLI from each gameloop with different camerea settings; each game loop runs on one of the vertical blanks so one of your DLI calls will happen "before" (called from the top blank) the display is drawn and one will happen after the display is drawn, the one called from the bottom blank (gameloop2). DLI Overhead: 3 row DLI's will occuply nearly the entire top blank, and cannot fit in the bottom blank while 2 row DLI's leave plenty of space for your own program code. Just like raising an event to scroll the entire screen, A DLI need be called only as frequently as you need to update it's target section of the screen (pan the camera). Exercises for setting up multiple DLI's and setting their animation rates: 1. Increase the scrolling speed of the top half of the screen to match the bottom, so they are both animated at 30 FPS (every other frame). 2. Change the demo to show three visible scroll zones; try to set up two zones scrolling horizontally in opposite directions or at different speeds, while the third "larger" zone (comprised of two zones) scrolls vertically or diagonally.
  23. sale postponed - sorry, personal issues cropped up.
  24. For sale is a Karin Maxi Drive for 65/130/800XE with ECI http://atariki.krap.pl/index.php/Karin_Maxi Floppy Drive 100% work. Im asking Karin Maxi Drive + postage = total Dollar US 86$ [paypal fee or gift] Video: http://youtu.be/C29tiSYxZ6g http://youtu.be/INxDaQCHliY Photo: http://stryker.pigwa.net/allegro/11113/karin_maxi_drive/
×
×
  • Create New...