Jump to content

desertfish

Members
  • Posts

    554
  • Joined

  • Last visited

  • Days Won

    14

Everything posted by desertfish

  1. I haven't really thought about that to be honest. The only thing that occurred to me is that you could make a version that uses ZeroByte's fixed v39 kernal rom to use LOAD instead of a CHRIN based file read loop to load large files much faster, like I did in the assembler. Saving will still be slow because SAVE doesn't yet work with banked ram. Also that version, like my assembler now, would only work with the patched ROM... If the patch won't get merged we'll be stuck with non working software
  2. Yeah I think they either use some modifying code that can't run multiple times or forget to reinitialize variables. Prog8 doesn't have uninitialized variables and everything is re-initialized to their initialization value when the program is restarted.
  3. Thank you Stefan. As long as you don't load the resulting output program, or loading it into a unoccupied piece of RAM as to not overwrite the assembler itself (so outside $0801-$5000 ish, look at the load addresses of the assembler program) you can indeed simply restart the assembler to continue editing or assembling code. (prog8 programs generally are restartable after exit).
  4. Update again with new file load routines. Note that a patched V39 ROM is required to run this correctly because it depends on the kernal's LOAD routine to work correctly across ram banks. The framework for loading multiple files is now in place and we have ample RAM to store them into - we're now using hiram banks so we can store hundreds of kb of source files. So the next thing to do in the next version is to implement some sort of .INCLUDE "file.asm" directive to be able to read from multiple source files.
  5. From the (limited) time I spent with this patched kernal it seems to work fine for me! So yeah go ahead with the pull-request on github. This is quite an important one, as it will probably fix a whole lot of data-load issues when running from sd-card (also I want to integrate it with my custom v39 rom build, because a few other patches are in there as well) edit: found an issue when loading to banked addresses when LSB=$02 , thinks work ok if LSB=$00
  6. some sort of "workaround" to load headerless files can be this: OPEN file CHRIN 2 bytes to the first 2 load locations in memory CLOSE file LOAD file in memory location+2 I built this into prog8 as load_raw() and it works like a charm, just requires a fair bit of extra code (hidden away in a library)
  7. the current LOAD routine already walks right over the I/O area I believe, so it didn't get worse (but not better either in this regard).
  8. Version 7.4.1 has been released https://github.com/irmen/prog8/releases/tag/v7.4.1 Documentation as always here https://prog8.readthedocs.io Even more improvements in generated code efficiency, resulting in smaller code that runs faster. improved code generation. optimizer is now smarter about accesses to memory mapped IO that shouldn't be optimized away performance improvements in the compiler itself, updated to Kotlin 1.6 fixed some illegal instructions in the conv module on c64 target other bugfixes documentation improvements
  9. Here's a 24 bit division routine from codebase64 that is an extended version of their 16 bit division routine (which I use in prog8), so I expect you can extend it once again to 32 bits. It looks smaller than your code, but I didn't measure. https://codebase64.org/doku.php?id=base:24bit_division_24-bit_result Also here's another person with a different looking 32 bits division routine but arguing that it is useful for small code sizes https://atariage.com/forums/topic/237463-looking-for-32-bit-division-routines/?tab=comments#comment-3240032 I haven't tried both of them but perhaps they're of some use to you but if it's always division by 60, perhaps you can cheat a bit? Start with division by 64 (which is a simple shift) and maybe this is precise enough already? otherwise perhaps there's a way to adjust the result somewhat to make it more precise, I don't know
  10. I think the callback idea is best. Even more so because I'm thinking of a callback that triggers after a "pattern" or "bar" so that you might be able to sync up some behavior with say, a drum beat or the rhythm of the music? would that be possible? Then we could create music games or puzzles or interesting visual effects (strobe light, whatnot)?
  11. While I was boasting about the reduced code size of the compiled Petaxian game, I now discovered that a bug has crept in in 7.3 that now makes the sound glitch out on the C64 build of Petaxian. I will investigate and fix this soon, hopefully. Weirdly enough the game still works fine with sound on the X16 build. update: found the bug and fixed it for 7.4, there was a new optimizer added that was too aggressive in removing double-stores
    Nice little lander game! I had fun playing it. Love the little details in the background and the menus. Well polished!
  12. Wow this sounds amazing! Is this an original tune for concerto? Or is it playing a coverted mod or something?
  13. Version 7.3 has just been released https://github.com/irmen/prog8/releases/tag/v7.3 Docs are here as always https://prog8.readthedocs.io/ More improvements in generated code efficiency, resulting in smaller code that runs faster. (see the post above this one for an indication of savings you might see) Also added a few small new quality of life features. fixed operator not priority: it is now higher prio than and/or/xor ! fixed division of signed bytes by 2 added new cos and sin builtin functions cosr8 sinr8 cosr16 sinr16, and also their unsigned valued siblings. These make it easier to deal with arcs of degrees 0-359 rather than 0-255 of the existing trig functions. added signed versions of the cx16 virtual registers: r0s - r15s including the L and H byte variants of them. less temporary variables generated and used more optimizations to expression evaluations compiler no longer uses cx16 R15 virtual register as tempvar unit tests now use KoTest as test framework.
  14. For comparison Petaxian compiled with prog8 7.0: 19639 bytes Petaxian compiled with prog8 7.2: 19405 bytes 234 bytes of overhead removed update: Petaxian compiled with prog8 7.3: 19258 bytes another 147 bytes of overhead removed by producing more efficient code
  15. Version 7.2 of the Prog8 compiler has just been released https://github.com/irmen/prog8/releases/tag/v7.2 Documentation is here https://prog8.readthedocs.io This is mainly a version with performance optimizations. Various parts of the code generator now create faster code, and sometimes also smaller code. Depending on your source code, you can observe pretty significant gains in resulting program size (tens to hundreds of bytes smaller). Other fixes: PETSCII block drawing character mapping was updated to now correctly separate certain box line characters Fixed type casting errors related to certain const propagation str is now allowed as a parameter type in subroutines (it is passed by reference/address) compiler no longer crashes when an input file doesn't exist gradle builds now automatically run installDist task after build updated to Kotlin 1.5.31
  16. The emulator supports character based file I/O just fine by virtue of just running the kernal ROMs. Character based I/O is done through kernal routines, and these work fine. We're talking about SETNAM, SETLFS, OPEN, CHKIN, CHRIN, READST, CLRCHN and CLOSE. I don't know how you call these from cc65.
  17. I picked up Elvira Mistress of the Dark, Elvira Jaws of Cerberus, and Graveyard Keeper on GoG for just a few bucks I played both elvira games back in the days on my Amiga, I wonder how they hold up today.... As for non-gaming software (which was the original question): as I said above I keep forgetting Steam also sells those. But I also never pay attention to them. (I have very few applications that I ever purchased personally. I mostly use free and/or open-source things. Even my development environment of choice -IntelliJ IDEA suite- is on a free license from them, very nice)
  18. For games, may I suggest you head over to GoG too they have a Halloween Sale going on as well. They're selling lots of retro (and new!) games but DRM free. https://www.gog.com/
  19. I always forget that steam also sells productivity tools
  20. Everything is public in Prog8, there's no concept of private accessibility. You can use scoping to structure your code though (modules, blocks, subroutines).
  21. Version 7.1 of the Prog8 compiler has just been released https://github.com/irmen/prog8/releases/tag/version7.1 Documentation is here https://prog8.readthedocs.io Here's a list of the changes: - removed %target directive because it was too confusing for what little it did. Just use -target command line option. - non-asmsub subroutines can no longer be inlined because the way this worked was not reliable - internal code refactoring to improve testability and reliability - several error/warning message improvements - added support for secondary alternative emulator to launch, with '-emu2' option (box16 in case of commanderX16) - fixes for various issues related to different output path - %asmbinary path related assembler bug fixed - float[] array initializer bug fixed - fixed some assembler bugs in swapping values with swap() - fixed bug in palette.set_color - fixed bug in optimizer that sometimes removed subroutines that were referenced, causing assembler crash - some other miscellaneous bugfixes and improvements.
  22. sound worked fine on the non-web based emulator with v39 roms for me. (indeed not on the browser emu)
    WOW!! The parallax scrolling is superb Sound only worked in the real (non-web) emulator for me, but that could be a limitation of that emulator?
  23. raster interrupts work fine in the web emulator
×
×
  • Create New...

Important Information

Please review our Terms of Use