Devin

Exceptional work!

I had Indy 500 back in the day. I still have it - controllers and all! I didn't like it as much as Spin-Out. Mainly, the cars do not "spin" when you hit a barrier. Instead, you got stuck in the wall, which for me, ruined the game.

Here's an old ad that has a ton of old Odyssey 2 games

My vote has to be for Spin-Out! I had hours upon hours of fun playing this game - and it should be rather easy to create.

I love that look! ... but the Atari only has a whopping 8 shades of gray. I can do something like attached image. The picture (at least to me) looks like there is an audience.

For original games, I love: Toyshop Trouble Go Fish - relaxing Elevators Amiss - damn hard (default level), but fun For ports of classic games: Four-Play - the computer is aggravating good Gunfight - Far more than just "okay" at the O.K. Corral

Thanks for your feedback guys. Right now there is a 2-2 tie between the green canvas and blue canvas. I might have to make the background dark gray, one of the "must have" boxers in this game will have black hair. I can also look into having different backgrounds depending on each boxer. This was a future enhancement, but it might become necessary for this one.

Hello everyone! I wanted to let you know that I am (finally) getting back to work on this project. I am currently working on the sound engine, so I won't have a new binary for a while. However, in the meantime, I've created some variations of the colors used on the fight screen. I would love to hear everyone's feedback on which color scheme they think is best. ... or even suggest a new one. Have a great day.

I forgot to mention that the subroutine does not clear the horizontal move register afterwards. This should be done at least 20 cycles after the subroutine returns - if you plan to use HMOVE outside the subroutine.

Here's a beautifully written algorithm that I found on these boards some time ago. It works absolutely great. Just call it during the vertical blank - or during the kernal. Be warned that this subroutine consumes two scanlines. I'm using a modified version in one of my projects. ;--------------------------------------------------------------- ; Subroutine: PositionSprite ; ; In : a = position. ; x = sprite (0 = player 0, 1 = player 1, 2 = missile 0, 3 = missile 1, 4 = ball) ; ; Out : None ;--------------------------------------------------------------- PositionSprite sta HMCLR sec sta WSYNC ;begin line 1 PositionSpriteLoop sbc #15 bcs PositionSpriteLoop ;+4/5 4/ 9.../54 eor #7 ;+2 6/11.../56 asl asl asl asl ;+8 14/19.../64 sta.wx HMP0,X ;+5 19/24.../69 sta RESP0,X ;+4 23/28/33/38/43/48/53/58/63/68/73 sta WSYNC ;+3 0 begin line 2 sta HMOVE ;+3 rts ;+6 9 So, if you want to put the player 1 in horizontal position 80, you would use it like this: LDX #1 LDA #80 JSR PositionSprite

All I have to say is: Wow! For a moment, I thought I had opened by Commodore 64 emulator! The graphics excel anything I thought possible on the Atari. The game itself, is incredibly fun.

Simone LOL

I haven't had a chance to work on the program for quite some time. Hopefully, I can get a better working demo out sometime next month. Thank you!

Here's the song for the Family Guy using the format. It spans several octaves. .byte #STYLE_NORMAL .byte #TEMPO_150 .byte #OCTAVE_UP .byte #NOTE_C | LENGTH_4 .byte #OCTAVE_DOWN .byte #NOTE_B | LENGTH_8 .byte #OCTAVE_UP .byte #NOTE_C | LENGTH_2 .byte #OCTAVE_DOWN .byte #NOTE_F | LENGTH_8 .byte #NOTE_B | LENGTH_4 .byte #NOTE_AS | LENGTH_8 .byte #NOTE_B | LENGTH_2 .byte #NOTE_F | LENGTH_8 .byte #NOTE_AS | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #NOTE_AS | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #NOTE_AS | LENGTH_8 .byte #OCTAVE_UP .byte #NOTE_C | LENGTH_4 .byte #OCTAVE_DOWN .byte #NOTE_G | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #REST | LENGTH_32 .byte #NOTE_A | LENGTH_8 .byte #REST | LENGTH_32 .byte #NOTE_A | LENGTH_8 .byte #NOTE_A | LENGTH_4 .byte #REST | LENGTH_8 .byte #NOTE_F | LENGTH_8 .byte #NOTE_G | LENGTH_8 .byte #NOTE_G | LENGTH_8 .byte #NOTE_F | LENGTH_4 .byte #NOTE_GS | LENGTH_4 .byte #NOTE_F | LENGTH_4 .byte #NOTE_A | LENGTH_8 .byte #REST | LENGTH_32 .byte #NOTE_A | LENGTH_8 .byte #REST | LENGTH_32 .byte #NOTE_AS | LENGTH_4 .byte #NOTE_A | LENGTH_2 .byte #STYLE_NORMAL .byte #NOTE_G | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #OCTAVE_UP .byte #NOTE_D | LENGTH_8 .byte #OCTAVE_DOWN .byte #NOTE_A | LENGTH_8 .byte #NOTE_F | LENGTH_8 .byte #NOTE_D | LENGTH_8 .byte #OCTAVE_UP .byte #NOTE_C | LENGTH_1 .byte #REST | LENGTH_8 .byte #NOTE_D | LENGTH_8 .byte #NOTE_CS | LENGTH_8 .byte #NOTE_D | LENGTH_8 .byte #NOTE_E | LENGTH_8 .byte #NOTE_F | LENGTH_8 .byte #NOTE_E | LENGTH_8 .byte #NOTE_D | LENGTH_8 .byte #NOTE_C | LENGTH_1 .byte #REST | LENGTH_2 .byte #OCTAVE_DOWN .byte #NOTE_AS | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #NOTE_AS | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #NOTE_AS | LENGTH_8 .byte #OCTAVE_UP .byte #NOTE_C | LENGTH_4 .byte #REST | LENGTH_16 .byte #OCTAVE_DOWN .byte #NOTE_A | LENGTH_8 .byte #NOTE_GS | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #NOTE_GS | LENGTH_8 .byte #NOTE_A | LENGTH_8 .byte #NOTE_AS | LENGTH_4 .byte #REST | LENGTH_16 .byte #NOTE_G | LENGTH_8 .byte #NOTE_FS | LENGTH_8 .byte #NOTE_G | LENGTH_8 .byte #NOTE_FS | LENGTH_8 .byte #NOTE_G | LENGTH_8 .byte #NOTE_A | LENGTH_4 .byte #REST | LENGTH_16 .byte #NOTE_F | LENGTH_8 .byte #NOTE_A | LENGTH_4 .byte #OCTAVE_UP .byte #NOTE_D | LENGTH_4 .byte #REST | LENGTH_4 .byte #NOTE_C | LENGTH_2 .byte #NOTE_CS | LENGTH_2 .byte #NOTE_D | LENGTH_2 .byte #NOTE_E | LENGTH_2 .byte #NOTE_F | LENGTH_2 | DOTTED .byte #SONG_END This is basically the quick-n-dirty MIDI import.

Sorry about that. The library currently supports 6 octaves (with varying support). With each octave, you can specify the 12 different notes. In the array, you can move up and down octaves. The idea is that a song can be started in a different octave (and tempo) based on gameplay.

Ironically, that's also what I named my library! This is probably a duplicate project - but it is a good way for myself to master Atari 2600 music. Well, "master", might be too strong a word. The whole idea was to store a simple sheet-music byte-code and use it to create sound. When complete, I can use all the old QBasic Play strings. I doubt I can even come close to tapping the full sound qualities of the Atari.

I'm trying to make the file format incredibly compact. Each melody contains a series of bytes where the first 4 bits contain the note/command (octave up, down up, tempo up, tempo down, change style,...) and the lower four bits contain length/data. For notes it has the following format: NNNNDLLL NNNN is the note from 0-11, 12 is a rest, D is a dotted note (1.5 times length), and LLL is the length of the note. The melodies have the following format: TableSong .byte #STYLE_NORMAL .byte #NOTE_G | LENGTH_2 .byte #NOTE_G | LENGTH_4 | DOTTED .byte #NOTE_E | LENGTH_8 .byte #NOTE_E | LENGTH_2 .byte #NOTE_G | LENGTH_2 .byte #NOTE_G | LENGTH_4 | DOTTED .byte #NOTE_D | LENGTH_8 .byte #NOTE_D | LENGTH_2 .byte #NOTE_E | LENGTH_2 .byte #NOTE_F | LENGTH_2 .... Each note is looked up in another table that contains the AUDCn and AUDFn codes. I compact it further by storing each of these using one byte with a second table containing the AUDCn values. VOICE_1 = #%00000000 ;0 Buzzy tones (AUDCn = 1) VOICE_4 = #%00100000 ;1 Pure tones (AUDCn = 4) VOICE_6 = #%01000000 ;2 Semi-buzzy (AUDCn = 6) VOICE_7 = #%01100000 ;3 Reedy tones (AUDCn = 7) VOICE_8 = #%10000000 ;4 White noise (AUDCn = 8) VOICE_12 = #%10100000 ;5 Pure tones (AUDCn = 12) VOICE_14 = #%11000000 ;6 Electronic tones 1 (AUDCn = 14) TableNotes ... ;=========== Octave 3 .byte VOICE_12 | 19;C .byte VOICE_12 | 18;C# .byte VOICE_12 | 17;D .byte VOICE_12 | 16;D# .byte VOICE_12 | 15;E .byte VOICE_12 | 14;F .byte VOICE_12 | 13;F# .byte VOICE_12 | 12;G .byte VOICE_1 | 4 ;G# .byte VOICE_12 | 11;A .byte VOICE_12 | 10;A# .byte VOICE_4 | 31;B ... TableVoiceControl .byte 1 ;0 Buzzy tones .byte 4 ;1 Pure tones .byte 6 ;2 Semi-buzzy .byte 7 ;3 Reedy tones .byte 8 ;4 White noise .byte 12 ;5 Pure tones .byte 14 ;6 Electronic tones 1 .byte 15 ;7 Electronic tones 2

The BTP2 music driver can play four channels (two out of each TIA channel), with reasonably decent pitch accuracy and a five octave range. It does gobble up some ROM and CPU cycles (46 cycles/line, and nine pages worth of tables) but the audio quality is pretty decent. EBTBTP2 could be even better, though--stay tuned. Sounds excellent. I created a thread on the homebrew page with some songs I imported from MIDI. It is extremely primitive at the moment.

Hello all, I've been working on a MIDI to Atari 2600 routine. Most of the work I created previously with an MIDI to QBasic converter. The main work is done by a VB program that reads a MIDI file, filters the channels and then is able to determine style (staccato, legato, etc..) and merge notes. Anyway, I've attached a few of a simple MIDI files I imported. I still have a a lot of work to do to make it match missing musical notes (mostly sharps). I plan to eventually to be able to also import and convert the beat track - drums, snares, etc... Each audible note takes one byte - so a long song will not take a ton of storage. Note use a timing table and a second table that is used to look up the AUDCn and AUDFn codes. The idea is that a PAL version should be able to sound identical. A few of the notes are a tad fast - I haven't written the code for dotted notes yet. I've attached very simple programs that play Angry Video Game Nerd theme Take Me Out to the Ballgame (baseball) Ghostbusters Jingle Bells Family Guy Here Comes Santa Clause AVGN.bin Baseball.bin Family_Guy.bin Ghostbusters.bin Here_Comes_Santa_Clause.bin Jingle_Bells.bin

It's looking great so far! I look forward to see how this project progresses. Cheers.

I found these on the Internet.

I did some analysis of the note charts that I found on the Internet for the TIA sounds vs. natural note frequencies. Although, the TIA is a tad off-key (understatement), most of the notes can be matched. I've attached a chart I created with a series of different octaves and where each AUDCn and AUDFn falls in the range. The pure tones have the best coverage of the notes. Anyway, I have a question and would like your feedback. If I was to substitute the "pure" tone for the "buzzy", "semi-buzzy", etc.... distortions during a melody, would it sound okay? In the chart, notice that A#2 has a matching "buzzy" value, but not a "pure" one. Octaves___NTSC.zip

Of course! Why didn't think of that! The opponent would definitely have to be a Mountee!

Ah. Thanks everyone. It appears my grandiose idea is nothing but a pipe-dream - and I'm not talking Mario Brothers I'll play around with sound some more. Its the only major "unknown" I still need to tackle. The documentation on the this site and the Internet is very helpful.

Great update! Out of curiosity, why not go to 4k? I can understand if the challenge is to create a great game under 2k - which you have accomplished with flying colors!