Jump to content

Devin

Members
  • Content Count

    487
  • Joined

  • Last visited

Posts posted by Devin


  1. 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.


  2. 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.

    post-17256-1213448312_thumb.png

    post-17256-1213448317_thumb.png

    post-17256-1213448321_thumb.png

    post-17256-1213448325_thumb.png

    post-17256-1213448329_thumb.png

    post-17256-1213448333_thumb.png


  3. Thanks a lot for this, I think this is the one I will use in my game, which currently has no horizontal positioning code.

     

    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.


  4. 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


  5. Wondering if any more work has been completed. This looks promising so I'll give it a bump.

    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.

     

    Just found this thread today. Can't wait to see this game get finished.

    Thank you!


  6. 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.


  7. Am I reading this correctly: your music data supports 12 notes per song? If so, that really isn't enough, I'd say...

     

    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.


  8. Have you seen music.h? Not saying your ideas aren't valid, just that much of the same work has already been done.

     

    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.


  9. I've been thinking a MIDI to BTP2 music converter might be nice, though I'd have to settle on what format I'd want to store the actual music in. BTP2 has a five-octave chromatic range with four voices, so it should be possible to make things sound pretty good.

     

    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


  10. of course you could always look into the atari synthsound subroutine or a variation of it. It takes alot of clock cycles to work though. I think it changes the audio channels every 2 scanlines. you actualy get extra audio channels with it too like atleast 3 instead of 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.


  11. 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

    post-17256-1207108272_thumb.png

    AVGN.bin

    Baseball.bin

    Family_Guy.bin

    Ghostbusters.bin

    Here_Comes_Santa_Clause.bin

    Jingle_Bells.bin


  12. This is my first homebrew for the 2600 written in assembly, and I am very proud of it, since I am only 14 years old. The name of it is "Vong" for Vertical pong. It plays like pong, but instead of the ball going side to side, it goes up and down, hence the name Vong. There is some AI, but it is not too good. I plan to change all of the colors to black and white, like the original pong. There is no scoring currently, but there will be in a future update. I would also like to add paddle support, and a 2 player option.

     

    Enjoy!

     

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


  13. 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


  14. 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.


  15. Ok, ok... I surrender: I had to remove the game over music, but now... the borders aren't deadly anymore :ponder:

     

    Bye :)

    Simone

     

    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! :)


  16. Can't wait to see the rest of your characters, Devin.

     

    Here's what I have created so far:

    • Line 1 contains characters that I created for my original Commodore 64 version. The second guy, in green trunks, is the champ.
    • Line 2 contains characters I created for a possible "Holiday" related sequel. They are Santa Claus, Frosty, St. Patrick's Day (I might put a shirt on him), Independence Day, Halloween (maybe), Jack O'Lantern (Halloween), and Easter (which is the goofiest picture ever).
    • Line 3 contains miscellaneous characters. The first two might go into a "Time" related sequel. I could also incorporate the Soviet from the top row. The ninja could get associated with feudal Japan. The next two are clowns: Pennywise from IT (from the book) and a generic clown (not evil). Finally, I have a lumberjack and a thief.
    • The last line contains characters from Homestar Runner. I doubt I would be able to create this, though I'm sure the creator would find it funny. I then have masked fighter and a stereotypical representative of spanish television. Finally, I have Michael Moore.

     

    I would love to hear everyone's feedback on the designs.

    post-17256-1205952559_thumb.jpg


  17. I was thinking of creating a two tables - about 60 bytes each (5 octaves). Each table would essentially be redundant except for cases where I have to transpose two notes to create a missing one. This might be too simple a solution since playing two frequencies at 50% of the time each, might not create the desired result.
    Apparently, the human ear is too sharp to be fooled in that way.

     

    Even if the two tones are changed every 1/60 of a second? Curses! :x


  18. Cybergoth's SID-to-TIA program works, but almost always produces music with a few bad notes. I've had success with hand-optimizing the output. It helps that this program can transpose, however, it can do so only an octave at a time. What would be nice is a music converter that has the ability to transpose by any amount, not just an octave. Doing so should allow for a closer match to the TIA's limited scale.

     

    I was thinking of creating a two tables - about 60 bytes each (5 octaves). Each table would essentially be redundant except for cases where I have to transpose two notes to create a missing one. This might be too simple a solution since playing two frequencies at 50% of the time each, might not create the desired result.

     

    Anyway, the Play statement in QBasic is quite advanced in the sense that octaves can be moved absolutely or relatively. The solution I was looking at would implement both - allowing songs to be created that can be changed during game play. The initial octave could be increased or decreased depending on game play. Naturally, to even attempt to get the full note range, I will have to stick to the "pure tones".

     

    This is just a thought now. Once I fix the ball bug in my homebrew, I'm going to attempt to tackle sound.


  19. Hello everyone, I am curious if any knows of an excellent Atari 2600 sound to music note tables.

    I found two guides by Glenn Saunders and Eckhard Stolberg - and they should be helpful by themselves.

     

    My ultimate goal is to be able to create an array in a programs that just contains encoded notes: quarter-C, full-F#, etc.... The Atari would then look up the pitch and distortion codes in an table and recreate the sounds. For non-supported notes, I might try to iterate between two close notes to create a blended one.

     

    Overall the plan is to be able to convert MIDI to Atari. I'll already created a program that converts MIDI to the QBasic Play Statement codes - which are pure notes. A conversion from QBasic Play to Atari 2600 should be incredibly straight-forward (knock on wood).

×
×
  • Create New...