Jump to content


New Members
  • Content Count

  • Joined

  • Last visited

Everything posted by sunofman

  1. Can it be used as binary "blobs" or would I translate some of that code to my language, to ba able to use it?
  2. You are right. However the laguage is exact. So writing code for a display kernel can be done easily.
  3. Well then I already has support for the graphics kernel, I have tested to write that code, and it worked. So there isn't anything specific that is needed for Atari 2600 support, more than a efficient compiler on pair with assembly. Is there anything I have missed? A bit curious, is there a C compiler that is efficient enough to write programs to Atari 2600?
  4. I agree on that. It was just some hasty translation, without much thought. I have support for what you talk about, it's quite essential.
  5. Ok! what parts is the graphics kernel? I have already converted the Collect program, doesn't that have a graphics kernel. I use the exact the same variable names and label names as the Collect program. What more programs has to be converted to get a full graphics kernel? Ok thanks for the advise on NES, I will tackle that later. But I will fix Atari 2600 first I guess. I used to play on it back in the early 80s, and later on i played games on c64, vic20 and NES and Lynx. So I will probably fix them also. But I think I will do things chronologically, so maybe Atari 800 is the next stop.
  6. Does any one know, why the empty part of the ROM file is filled with $FF ? In my ROM generated in my language, the empty part of the ROM is filled with $00 and is fully working in stella. But I can change the empty filling to $FF if it's a problem when writing Atari 2600 programs. Otherwise, that rom is identical to Collect ROM file. At the moment, the program converted to my language is mostly translated to my language. But some instructions is in-line assembly. And there is one instruction type that is still machine code (relative BEQ and BNE), that should be fixed so it can use my language syntax with 100% efficiency, like it was hand-coded assembly. But I will fix that sooner or later. What is the reason why DASM is used to write Atari 2600 programs? Is there some special functionality in it that is needed? I'm thinking of making a feature to disassemble Atari 2600 roms, and be able to recompile them immediately and start converting and modifying. I already have a disassembler half made. And it can probably be fixed to it uses real names for hardware registers automatically if i spend a little time on it.
  7. OK! Now I have managed to compile a binary identical program to Collect in my language. But there is some minor things that I have to fix, before it's usable as a Language for Atari 2600. I had to patch the program with some in-line machine code. I don't now how the code works, but I guess I will learn something along the way. Even if I don't don't know how Atari 2600 works, it will still be useful for 2600 projects. If I can use it without knowing anything, maybe it will be useful for someone who actually know how to program the Atari 2600.
  8. What type of macros is needed to make decent code for 2600 and why? Well you can inline assembly and binary data and mashine code in this language.
  9. ;======================================== ; Sync Signal ;======================================== VerticalSync: lda #2 ; LoaD Accumulator with 2 sta WSYNC ; STore Accumulator to WSYNC, any value halts CPU until start of next scanline sta VSYNC ; Accumulator D1=1, turns on Vertical Sync signal sta VBLANK ; Accumulator D1=1, turns on Vertical Blank signal (image output off) lda #47 sta TIM64T ; set timer for end of Vertical Blank sta WSYNC ; 1st scanline of VSYNC sta WSYNC ; 2nd scanline of VSYNC lda #0 ; LoaD Accumulator with 0 sta WSYNC ; 3rd scanline of VSYNC sta VSYNC ; Accumulator D1=0, turns off Vertical Sync signal ------- That would be translated to... < ======================================= Sync Signal ======================================= > VerticalSync: #2 =WSYNC =VSYNC =VBLANC < turn on Vertical Sync and Vertical Blanc signal > #47.0 =TIM64T =WSYNC =WSYNC < first and second scanline of VSYNC > #0 =WSYNC =VSYNC < third scanline, and turn of Vertical Sync signal >
  10. Here is another translation of this assembly... ;======================================== ; Define Start of Cartridge ;======================================== ; define a segment for code SEG CODE ; ROM starts at $F000 ORG $F000 ----------------- to this code... ;======================================== ; Define Start of Cartridge ;======================================== F000: < ROM starts at $F000 >
  11. Well it would be written even shorter ... < ======================================== Define RAM Usage ======================================== > BackgroundColor:80 < holds background color for first scanline of frame > PlayfieldColor:81 < holds playfield color for first scanline of frame > LineCount:82 < holds # of scanlines left for the kernel to draw > ...that would be more correct code using my language. You don't need to set origin in this case.
  12. I could translate some code segments, starting with this... ;======================================== ; Define RAM Usage ;======================================== ; define a segment for variables ; .U means uninitialized, does not end up in ROM SEG.U VARS ; RAM starts at $80 ORG $80 ; holds background color for first scanline of frame BackgroundColor: ds 1 ; stored in $80 ; holds playfield color for first scanline of frame PlayfieldColor: ds 1 ; stored in $81 ; holds # of scanlines left for the kernel to draw LineCount: ds 1 ; stored in $82 -------------------------------------------------- That code would look like this... < ======================================== Define RAM Usage ======================================== > 80: < RAM starts at $80 > BackgroundColor:80 < holds background color for first scanline of frame > PlayfieldColor:81 < holds playfield color for first scanline of frame > LineCount:82 < holds # of scanlines left for the kernel to draw >
  13. Thanks! Yes, I could give a overview, and answer questions. Well it support structured code. And it's a lot easier than assembly. And it's a good language for someone that is familiar with assembly. And programs would be a lot smaller than assembly programs, without loosing functionality. My brother translated a C64 assembly program with raster graphics. And that program started on the first try, without rewrite. And that was his first program in that language. So it's extremely easy language if you know assembly. And it's easy to convert assembly programs to this language. So in some ways it's easier than C coding, and easier than assembly. It's more low level than C. And programs are more compact than c code, and assembly code. And I could also integrates specific functionality in this language, so It's also more hi level than C. A bit like basic, with performance almost almost on pair with assembly. So if there is corner cases, or special syntax for easier programming, than I could make that if people would use it. It is also easy to write timing specific code. I could write a table, how much data and cycles everything takes later if someone is interested.
  14. Well, another tought. If I have your permission SpiceWare to use your code, I could translate that to my language. Are you okay with that?
  15. Well you don't know if what you say is true. I have written my language, and I know what I have done. I asked if there is any assembly code that is suitable. If a normal assembler can't be used, then thats ok, I will fix that. My language isn't based on anyone else assembler or C compiler or anything like that. It is a language made from scratch. It translates to 6502 directly. And 6507 has the same OP codes as 6502, hasn't it? Even if it doesn't than that could be fixed quite easily. And the limited adress space for 6507 isn't a problem. My language does not use a runtime library. And if some code need to be 100% exact, than that can be fixed also, if I have machinecode to go after. To as I alread said. I can translte machine code, in worst case. So if there is a short binary file that is suitable, that would be okey also.
  16. Hi! This is my first post here. ​ ​I have created a new computer language, that makes 6502 code. ​Before I release it, it would like to test to make a Atari 2600 program. ​ ​But as I don't have time to learn all about 2600 now, I wounder if there is a assembly program I can translate as a example. After that maybe someone would like to test it for writing their own programs. And I can provide the code for that program that i translate, as a programming example. Does anyone know of some suitable assembly code for this? I worst case I could take some machine code, and translate that. ​ ​Any ideas? And where can I find info about the used fileformat for Atari 2600 emulators? ​ ​ ​
  • Create New...