Jump to content


Popular Content

Showing content with the highest reputation since 12/02/21 in Files

  1. Version 1.0.0


    Tetrads is a clone of a popular falling brick style game. So you'll know how to play it. This version has an amazing soundtrack, which changes tunes every 40 lines cleared. There's a total of 5 unique songs which were designed specifically for the X16's combination of FM and PSG. The backgrounds, which represent science and technology, also change every 20 lines cleared. This gives the game a sense of progression and makes it not only a fun game by an adventure in sight and sound! Keyboard controls: ----------------- LEFT/RIGHT/DOWN - move bricks Z/X - rotate left/right SPACE - Drop brick ESC or RUN/STOP - Abort game RETURN - Pause game SNES controls: ----------------- LEFT/RIGHT/DOWN - move bricks Y/B - Rotate left/right X - Drop brick START - Pause SELECT+START - abort game
    8 points
  2. Version 1.0.0


    The Complete Game! New version with better graphics, sound, and music than before!
    7 points
  3. Version 1.1


    This is the initial version of Calliope, a music library player for Zsound's ZSM music files. The current version of the player is complete as a simple browser/player. You can put any .ZSM files into any folder and it will let you browse to it and play them. This is the initial version, and is far from implementing all the features I want to do. However, this is not a work-in-progress mockup - it is fully functional and useful for browsing your audio assets if you're making a game, or just like listening to tunes. The download includes a collection of various music I've collected and converted into ZSM format. The folders are organized by their source - most are from VGMrips.net (Arcade folder) but since the Zsound VGM conversion tool is able to convert other chips into the Commander X16's chips' formats, you'll find many tunes from Sega Genesis or games that used the YM2202. In the future, I will be adding even more chips to the conversion tool (NES APU being the one I intend to do next). Furnace / Deflemask folders are also present with a few examples from Deflemask's demos collection, and in the Furnace folder is a collection of tunes designed NATIVELY for the Commander X16. Furnace tracker supports VERA PSG, and it can export these tunes directly into ZSM format. Some members of the Furnace discord have submitted demo tunes which are included along with .TXT files giving them credit (no meta data in ZSM for such details). The next major feature will be to create, save, and load playlists of music and leave it running with your tunes playing back on REAL HARDWARE. What could be cooler than that? The download is in the form of an SD image, as emulators do not let you change directories on the Host FS. I've also included ZIP archives for the entire collection+Calliope, as well as only Calliope and the default skin in case you only need to upgrade your player from 1.0
    7 points
  4. Version 1.0.0


    Slideshow showing some of the progress of the Commander X16 project.
    7 points
  5. Version 1.1


    A "unix" like Dos Shell with a bunch of builtin commands to make day to day file operations (much) more convenient than via a Basic prompt. Requires R41. Tip: save this as AUTOBOOT.X16 to your sdcard and it will load every time you start the emulator. Short description of the commands and Source code (Prog8) available here https://github.com/irmen/cx16shell/
    6 points
  6. Version 1.0.1


    While waiting for the X16 to get real, I started to design my own computer case. I want it to resemble the keyboard or wedge-shape cases of the 80ies era. I owned a TI-994A and a Atari ST back then and I wanted to have something similar where I can put the X16 board in. I've integrated a Xtrfy TKL K4 keyboard and integrated a MISTER, Raspberry Pi (and a KVM Switch). I've published the design on Thingivers, where you can find the latest versions (I won't update here): >>Link Assembly might be a challenge and you have to see what type screws to use to mount things together. LICENSE: Creative Commons Attribution-NonCommercial-ShareAlike (CC BY-NC-SA 3.0)
    6 points
  7. Version 0.0.3


    This is an in-development game that I have been creating. It's main purpose is to aid in a set of tools I've been developing for creating VERA graphics resources (https://github.com/jestin/gimp-vera-tileset-plugin and https://github.com/jestin/tmx2vera), however the project has recently started to take on a life of its own. This is a very incomplete game (only one partially complete level, and no real goals), but should give a feel for how the graphics and game play will be. When more features are added to the game, I'll update this demo. This requires emulator version 41.
    4 points
  8. 57 downloads

    A new little intro, featuring full frame rate vectors! Original music by cerror. See their other music here: https://modarchive.org/index.php?request=view_profile&query=85822 Thanks! R38: Working R39: Working R40+: Untested
    4 points
  9. Version 1.0.1


    Please find below a new ROM flash utility that we ( @Wavicle and myself ) have created in preparation for the CX16 production release. When you have the CX16 actual hardware, then this utility is to be used to update your CX16 ROM with a newly released ROM.BIN file, once such become available. However, for those curious to try, you can run this tool on your emulator. Just deploy the PRG file and a newly ROM.BIN file onto an SD card image. Start the emulator with the SD card image option, and load the CX16-ROM-FLASH.PRG, and run the program. You'll see the flashing procedure in action, first loading the ROM.BIN completely into the internal memory first, and it will wait for a key press from the user. Once you press the key, the ROM will be flashed. Once the ROM flashing process is completed, the CX16 will reset. (Not sure that after reset, the rom will have the latest image then in the emulator, but it's worth to try ...). This is the first release of this, and further release will be made. Also this tool will like make its way to the official production software stack. The execution of this program, on official CX16 hardware, confirmed that the ROM upgrade process is feasible and that the ROMs are upgradable.
    3 points
  10. Version 1.1


    This is a topdown racing game. If you ever played Rally Speedway for Commodore 64 or Atari, it will feel familiar. I consider it a late sequel, somewhat improved actually and hopefully still fun. Starting the game: (The TRY-IT-NOW-button is disabled because the game is developed for the latest release of the emulator (r41). All game files should be in the same directory. Depending of how many game controllers you have, this is how you start the X16 emulator: No controllers: Just start the emulator and use the following keys: Ctrl - Button A, Alt - Button B, Enter - START, Cursor Keys - UP, DOWN, LEFT, RIGHT. Naturally, you can just play in one-player-mode. One controller: Start the emulator with -joy2. Player 1 will use the keyboard and player 2 the game controller. Two controllers: Start the emulator with -joy1 -joy2. For example if you have two SNES controllers and want to load and run the game immediately: "x16emu -joy1 -joy2 -prg rallyspeedway.prg -run" Controls Up - Start the race when cars are in position A Button - Brake (the cars will accelerate to maximum speed automatically) B Button - Return to menu when race is finished Start Button - Pause game Further instructions This is an open world racing game. For every track there is a certain distance you have to drive. When you have driven the given distance, you are ready to cross any finish line you happen to find. Remaining distance is displayed in the bottom corner of the screen. Most of the time you will probably just drive the default route by following the road and continue straight ahead in every crossing if there isn't an arrow to point you in a certain direction. But you can also find your own way. Just remember that every time you crash or get too far away from the other car, the race will pause and you will be brought back to the default route. For every crash a penalty of one second is added to your time. This is also the case if you are outdistanced by the other player. You can only be outdistanced as long as the other player is on the road and driving the standard route.
    3 points
  11. Version 1.0.0


    This is a character editor written in BASIC. Both layers are being used so all 256 characters in a font can be modified without affecting the program. The start-up of the program is slow due to character rom being written into layer 0 so it can be edited. Also had to clear layer 0 ram. Unable to use Try-In as program requires the the CHAR-EDIT-IF file. Once the program is loaded you can press L to load the EXAMPLE1 file so see an alternative character tile set. Download the SD image to use. I've made an assumption about where the required interface data file is located and where the user data files will be. Unzip the sdcard-pal-edit.zip file and start the X16 emulator x16emu -sdcard sdcard-pal-edit , once it starts load"*",8 and run it. CHAR-EDIT-IF EXAMPLE1.CHAR CHAR-EDIT.PRG char-edit.bas sdcard-pal-edit.zip
    3 points
  12. Version 0.3-beta


    You get six chances to guess the secret word. It is one of about 2500 commonly-used English words with exactly 5 letters. Just type the word and hit RETURN/ENTER to see if you guessed it correctly. If you had any letters in the correct position, they will be highlighted as green. If you guessed a letter that is in the secret word, but in the wrong position, it will be yellow. Any letters that aren't highlighted are not in the secret word, so you can eliminate those from later guesses. For more information and the code (which also can be built for the Commodore 64), check out the repo on GitHub: https://github.com/SlithyMatt/cbm-wordslide If you see any apparent bugs, or words that should or shouldn't be included in the list, please enter an issue on GitHub, or a pull request with your own fix -- adding or removing words from the list (2500words.txt) is trivial, and an easy way to contribute to this project!
    3 points
  13. Version r41 ("Marrakech")


    Precompiled emulators for Windows, Mac, and Linux. This is the latest version. Older versions can be downloaded from the GitHub releases page. (Note: To run on Mac use "Ctrl-click/Right-click > Open" instead of "Double-click" due to security protocols)
    3 points
  14. Version 0.8


    This is a space invaders inspired game. Use the mouse or joystick to control the player ship. The shield segments can take 2 hits each. If enemies get too close you retreat back to the last level. You lose when all your lives are gone or you fall back to earth level again. Now with 7 playable levels INVADERZ.PRG works on actual hardware and requires emulator R41 or newer! INVADERZ38.PRG works with "Try it now" button and emulator R38. Don't use on latest emulator or real hardware. Roadmap: more diverse enemy formations enemy attack raids over the sides power ups (shields, double cannon, disruptors etc.) boss enemy joystick control done music done Different enemy sprites. done Sprite animations. done for player sprite and enemies fade in/out of palettes and backgrounds. done more levels with more backgrounds (all planets of the solar system), done sound effects basics done title screen How to use with the emulator installed locally on your machine: Unpack ZIP file contents into the same directory as the emulator. Start the emulator, then enter LOAD"INVADERZ.PRG" RUN
    2 points
  15. Version 1.2.2


    This is a Breakout/Blockout/Arkanoid inspired game. . It is my very first try on the X16. You have to use a mouse or a joystick (cursor keys + enter on the emulator) It's tested an working on real hardware. Available power ups (no keycodes, you have to catch the dropping badges): [L]: adds one live to player [M]: paddle is magnetic for 30 seconds. Can only hold one ball at a time. [C]: twin laser cannon for 15 seconds, 16 rounds in a row (if you are quick). [D]: Duplicates ball, so now you can have fun with 2... Keyboard commands: 's': sound on/off. 'p': pause game 'q': quit game. Use the "Try now" button to test in browser window How to use on the emulator: Unpack ZIP file into the same directory as the emulator. Start the emulator, then enter type LOAD"BRIXX.PRG" RUN How to use on X16 hardware: Unpack ZIP file on SD card. Put into X16 hardware Power on type LOAD"BRIXX.PRG" RUN Let me know what you think...
    2 points
  16. Version 1.0.3


    For the other person who also prefers Windows XP in 2022. Compiled on Windows XP using Cygwin32. * This is unsupported, please use Michael Steil's official downloads if you are not using Windows XP.
    2 points
  17. 25 downloads

    Edit: I am not currently developing this project. I'll leave this here as it might be interesting to someone! Happy New Year all! Given the site is a bit slow, I thought I'd show off the latest version of my player. The biggest change in the latest version is that the commands now have 2 bytes of variable space to store their state, hopefully leading to some more interesting effects. You can hear an example with the 'warbling' on the track included. It's not vibrato by any stretch, but adds a little something. Hopefully you can hear the difference to the previous version here and agree its an improvement! (I am by no means a musician, so your mileage on that may vary!) The 'tracker', BitPlayer, that I'm using and developing is still relatively basic in terms of its UI, but is slowly but surely maturing. This uploaded .prg file is what is produced when the X16 emulator is launched from the tracker. It's all hosted on Gitlab here. The .json file attached is the 'mod'. There are of course a fair few things to do, the list is something like this: PCM support Change the output to my own new templating engine instead of ca65 YM2151 support (X8 depending) Change the sound engine to use a common engine with the emulator that better represents the X16 - Probably by embedding a emulator directly into the application The new templating engine removes all the typical restrictions that 'macro assemblers' can have. It's written in c# and is currently based on the Razor engine. As such it's easy to embed within an application like BitPlayer to produce 65c02 asm. The engine and the compiler have a little way to go, but if you're interested there is more information here. The track was originally by Archyx and can be found here.
    2 points
  18. Version 1.0.1


    Find attached a small demo program that calculates the angle between the middle point of the sceen and the mouse pointer position. This demo only runs on the R39 emulator version of the cx16. The angle calculated is between 0 and 63, so each quadrant in the circle has 16 different angles (0 to 15). Please comment to the following article that goes into details on this atan2() approach ... Sven
    2 points
  19. Version 2.0.1


    Writing BASIC programs longer than 10 rows on the X16 is a tedious experience. The text editor is very limited, much is about struggling with row numbers. This is an extremely simple compiler (sort of at least) for Windows that lets you write your BASIC programs in your favourite text editor with labels. The compiler outputs a new text file with the extension ".bas". It adds row numbers and fills in the right row number after the commands "GOTO", "GOSUB" and "THEN". No installation is needed, just copy the only file to the directory of your choice. Usage: x16LabelCompiler <filename> [first row number] [step between row numbers] Labels must end with a colon (":"). Labels must not be reserved keywords in BASIC. Labels are preserved in the generated code by inserting "REM" before them. Empty rows are removed. All letters are converted to uppercase. A sample program called "guess_the_number.txt" is included. To compile the program: x16LabelCompiler guess_the_number.txt To start the emulator, load the generated file and run it immediately: x16emu -bas guess_the_number.bas -run
    2 points
  20. Version 1.0.2


    A demo showing a heap memory manager being functional, dynamically allocating and freeing memory blocks of various sizes in banked memory of the CX16.
    2 points
  21. Version 1.0.0


    Here is the 2021 version of my X16 Christmas Demo, including new graphics and my own YM2151 arrangement of "The Carol of the Bells".
    2 points
  22. Version 1.0.3


    A Sokoban clone for the Commander x16. This started out, mainly to see if I could grasp the concepts behind the x16. No sounds or music, since this is a pure puzzle game. I have put in a fun level set called 'Sasquatch IV', publicly available at http://sneezingtiger.com/sokoban/levels.html. The code for this game can be found at https://github.com/envenomator/x16Sokoban.git Have fun!
    2 points
  23. Version 1.1.0


    This demo features 3D rendering to a 256x240@8bpp surface with full transformation calculation, texture mapping and per-pixel depth buffering. The model is a decimated Spot test model with 512 vertices, 1020 triangles and a 256x64 texture. So, I wrote this just to get familiar with this system and figure out how to write and optimize a 3D math for it. Also, it would makes a nice reason for me to get up and do some coding streams, as shown here: Only runs on r39 since I can't find documents for older versions. There's still bunch of incorrect pixels due to depth buffer precision problems. Controls: A/D - Move camera left/right W/S - Move camera up/down Q/E - Move camera backward/forward (Z value should be an unsigned number but the UI only displays signed numbers) J/L - Rotate left/right (yaw) I/K - Rotate up/down (pitch) U/O - Tilt left/right (roll)
    2 points
  24. Version 0.9


    VTUI (Vera Text User Interface) library Can be used to create text user interfaces using VERA instead of relying on the KERNAL functions for writing to screen. The library is less than 1KB which means it can be loaded into Golden RAM at $400. As an alternative, include files are provided for Acme and CA65 assemblers. See https://github.com/JimmyDansbo/VTUIlib for documentation, examples and include files.
    2 points
  25. Version 4.3


    A WIP port of Advance Wars for the GBA to the commander x16 Instructions/controls are here: https://github.com/cnelson20/x16wars/blob/master/docs/README.md I recommend using the native keyboard controls, so WASD to move the cursor/within menus , I as the 'a' button and U as the 'b' button.
    1 point
  26. Version 0.0.3


    Hi, Find a first playable demo of Equinoxe, my Commander X16 shooter ... I know it's not much yet, but I've come from very far making this. To make this, I had to learn how to: - implement a memory manager algorithm for vram on the vera - implement a memory manager algorithm for bram - implement a (fast) collision detection algorithm using spacial hashing technique - implement a fast method to shoot bullets to an angle direction - implement a fast method to calculate the angle between 2 coordinates (so calculate the unit vector) - fixed point arithmetic - sprite design using blender and spriter - tile design - implement a dynamic tile walking algorithm - vera library with all kinds of functions to paint sprites and tiles and control the video ram - dynamic level loading - memory banking - mouse control of the CX16 and more ... So as this demo may not be much, I've really learned a lot on this path to make this. And still continuing to develop this game as time floats... Let me know in the comments if this is something you like or not ... This demo must be downloaded as the emulator version on the web does not allow to load a card. So unzip the cx16.zip and a cx16.vhd file will be created. Load the game with x16emu -sdcard cx16.vhd In the emulator, type load "equinoxe.prg", 8, 1 Enjoy! Sveni
    1 point
  27. Version 0.0.1


    Note the title: CURRENTLY A MESS. I am aware of it. Painfully. Without really thinking about how to get it done, I just sat down and started writing it, adjusting my C source as I needed to. Now it's time to rewrite it, probably from the ground up, and I'm looking for suggestions. I'm thinking I need a kind of text buffer for the invaders, which can double as a collision map. Similarly for the tank. Even the houses... heck the whole screen kind of needs a buffer. It's only 4K maximum (and probably only 2K). Otherwise I'd have to look at VERA to see if there's a collision, and I don't like the idea of doing that. But maybe a text buffer is a bad idea? And the sound -- ugh! I am incompetent with X16 sound. If only we had SID... Well anyway in order to do anything useful I'm going to have to have multitasking, and on the X16 that means I'm going to need some assembly running on an interrupt or something like that. Which means I'm going to have to re-learn all of that.
    1 point
  28. Version 1.0.0


    PhantomX16 A remake of Phantom Slayer game that i used to play on a Dragon 32 back in the day. This game could really make you jump. I have used this as a learning exercise for 6502 assembly language and programming on the Commander X16. Sounds and graphics are faithful to the original game. Controls: Arrows for left/right/forward/backward. Space key to shoot. T key to transport ( If you can find it in the maze ) This works on R39 of the emulator. Enjoy!
    1 point
  29. Version 2.0.0


    When programming in assembly language, quite often you will need to do calculations that would normally require floating point math. Those subroutines are available, the same ones that BASIC uses, but they are very slow. And if you're programming in assembly, you're doing so because it's much faster than BASIC, so using those routines can defeat the purpose, particularly if you need to do a lot of such calculations. Ideally in assembly language you want to have most of your variables consisting of single bytes, not the five used for floating point. It's having to move all those bytes around and doing calculations involving all of them that makes the floating point subroutines slow. And if you're going for speed, you can make a tradeoff: increased speed at the expense of accuracy. A function involving a single byte can just be a lookup table. Over the last several years I have developed a number of lookup tables and subroutines that enable some very fast math on the 6502 and now 65c02. FASTMATH.BIN is many of them compiled into a single 8kb file that can be loaded into banked RAM. These lookup tables and functions will work on all revisions of the X16 emulator, and indeed will work on any 65c02 system as long as the file is loaded at $A000. The functions are all called through JMP redirects in page BF, and those JMP table locations will not change if I do revisions on the code. I'm pretty sure I killed all the bugs, but some might have slipped through. This is probably going to be the final revision of FASTMATH, barring some sneaky bug hiding in the code. There's only 6 bytes left anyhow. The file fastmath.txt contains detailed information about each lookup table and function and how to use them. The file FASTMATH.BIN is the binary that must be loaded into banked RAM.
    1 point
  30. Version 0.8b


    XCI is a graphical adventure game engine for the Commander X16. It is inspired by past engines such as SCI and SCUMM, but designed to maximize the potential of the X16 and keep the games just small enough to run, and allow developers to create games without having to program in BASIC or Assembly. Learn more about XCI on the official GitHub page: https://github.com/SlithyMatt/x16-xci There you will find all the source code, documentation, and example code and templates. There is also a tutorial series currently in production on YouTube: In the downloadable ZIP file you will find the engine executable binary for the X16 (XCI.PRG) and two embedded archives of the Windows and Linux software development kits (xci.exe). The SDK is written in standard C and can be compiled to pretty much any modern platform, including Mac and Raspberry Pi. Stay up to date by watching the GitHub, and occasional builds will also be uploaded here.
    1 point
  31. Version 1.0.1


    Huge Character Demo prints all the characters in the ROM hugely: PETSCII and ISO8859-15 including ASCII. The faster version uses some new X16 BASIC v2 keywords: BIN$ and LOCATE, but the slower R38 version uses BASIC code or SYS PLOT to do the same. Both programs use the SYS FETCH Kernal function to read character data from ROM bank 6. It's the slower R38 version that runs using the Try it now button. The zip-file contains a version for R38+ and faster versions for R39+ and the open source code as text. This is FOSS with GPLv3 license. One could e.g. develop this into a program to print banners. This is also on GitHub: https://github.com/mobluse/chargen-maker I'm open to suggestions on how to improve the code and make it faster.
    1 point
  32. 74 downloads

    Hope you enjoy this little intro! Best viewed on a local emulator. The web one doesn't seem to handle the audio too well. More on the audio player: Original mod by Archyx. See their other mods here: https://modarchive.org/index.php?request=view_artist_modules&query=69244 Thanks for looking. R38: Working R39+: Doesn't work (has bank switching)
    1 point
  33. Version 0.1.0


    For the last two years, as I relearn BASIC, I've been writing a book. It has been difficult to keep going, as I'm also studying for a Master's in Cybersecurity. This is a teaser of how it looks. The contents section shows the topics being covered. At the moment, it is around 260 pages. I'm curious about any feedback on how it looks and reads.
    1 point
  34. Version 1.0.0


    The BitMagic example. It decompresses (inflates) a 320x240 256 colour image, from the 32k .prg file.
    1 point
  35. Version 1.0.0


    This demo is made from original game assets and translating the VGM tune into YM2151 + VERA PSG. I made this demo because I think too many people forget just how great the graphics can be on the X16. I also think the FM music is vital to the 16-bit era of gaming, so this demo shows how the Commander X16 can deliver the goods if you like a 4th-gen experience.
    1 point
  36. Version 0.5.0-alpha


    This is an old video (hopefully I'll be able to make a new one soon): The CONCERTO synthesizer is what I intend to be the sound generating side of a music making software for the Commander X16. It uses the 16 voices of the VERA and the 8 voices of the YM2151 and aims to get the very maximum out of them. It is not quite there yet but has a lot of strengths already. The main features: 32 synth timbres (i.e. sounds) 16 monophonic channels, each playing a dynamically assigned synth timbre up to 4 PSG oscillators and 1 YM2151 voice per timbre up to 3 envelopes and 1 LFO per timbre pitch, volume and pulse width modulation vibrato volume control per voice ("velocity") pitchbend, volume and vibrato automation save and load presets / banks (a bank is the entirety of all 32 loaded timbres) comes with one bank of "factory" sounds The whole sound engine is exposed via an API that can be used by other applications. Concerto also comes with a player. If you have problems with the audio quality in the "Try it now", download and run in the offline emulator with the command line option "-abufs 12" or more. To use file loading and saving, you must use an SD card. For more information, look into the README and the source files and/or send me a PM. If you find bugs, please let me know, or post an issue on GitHub. https://github.com/biermanncarl/cx16-concerto Find the devlog here: https://www.commanderx16.com/forum/index.php?/topic/1079-concerto-dev-log/ Find m00dawgd's Command Tracker which will likely use Concerto: https://www.commanderx16.com/forum/index.php?/topic/978-command-tracker-dev-log/
    1 point
  37. Version 1.0.0


    An excel spreadsheet to help manage VERA VRAM usage. Has chart to display usage and location of Layer 0,1 and sprites. Available via GitHub, https://github.com/JustinBaldock/X16-VERA-VRAM-Helper
    1 point
  38. Version 0.11


    cc64 is a small-C compiler, written in Forth, targeting the 6502 CPU. It's hosted on the C64, on the C16 with 64k RAM, and now on the X16. Runtime targets are available for all 3 platforms, on each host, allowing cross-compilation. The code lives at https://github.com/pzembrod/cc64. It's licensed under the 2-clause BSD license: https://github.com/pzembrod/cc64/blob/master/COPYING See https://github.com/pzembrod/cc64/blob/master/Usage.md for usage. See https://github.com/pzembrod/cc64/blob/master/C-lang-subset.md for details about the supported subset of C. See https://github.com/pzembrod/cc64/blob/master/Lib-reference.md for the the LibC subset that comes with cc64, plus the lib's deviations from the standard.
    1 point
  39. Version 0.0.7


    BASLOAD lets you write BASIC programs without line numbers in the editor of your choosing. BASLOAD runs natively on the X16. As it's name implies, BASLOAD loads BASIC programs stored on the SD card into RAM. While loading a file, it's tokenized so that it can be run by the X16's built-in BASIC interpreter. Source files are stored as plain text that can be edited in almost any editor on the X16 or on a modern computer. There are, however, special bindings for the text editor X16 Edit making the programming workflow more convenient. Instructions on how to use BASLOAD and source code may be found here: https://github.com/stefan-b-jakobsson/basload BASLOAD workflow.mov
    1 point
  40. Version 1.0.0


    This is a console application for Windows that will convert png images to a format that the video controller (VERA) of the Commander X16 can read. Both indexed images (which contain a palette) and full-color images are supported. The original file can contain an image or a number of tiles or sprites with max 256 colors. For conversion of images, the width of the image must be 320 or 640 pixels. Height has no restrictrions. For conversion to tiles or sprites, the width and height of each tile/sprite must be specified. COLORS Bits per pixel (BPP) in the generated file will depend on how many colors the conversion results in. The number of colors might be reduced because the color depth of VERA is limited to 12 bits. In other words several 32-bit colors in the original image might be converted to the same 12-bit color. Semitransparent colors (0 < alpha < 255) will be treated as solid colors. For conversions of images with 16 colors or less, up to 13 colors will be displayed in the console window. Due to limitations of the console itself this is the maximum number that can be displayed correctly. TRANSPARENCY The first color of the palette might be transparent when rendered by VERA. This is for example the case when a sprite is rendered in front of a layer. Therefore it can be absolutely crucial which color in the original image that will receive index 0 in the generated palette. The selection is made in the following way: 1. If the original image is indexed (has a palette), the color with index 0 in the original will also receive index 0 in the converted image. 2. If the user has explicitly stated which color should be the first, this color will receive index 0. 3. If nothing above applies, the color of the top left pixel will receive index 0. OUTPUT At least two files will be generated: a binary file with image data and the palette in binary format or in the format of assembly source code or BASIC. As an extra bonus a BASIC program that displays the image/tiles/sprites can be generated. INSTALLATION The application is for Windows and depends on .NET 6.0. No installation is needed, there is just one executable file. SYNTAX X16PngConverter [-help] [FILENAME] {-image|-tiles|-sprites} [-height] [-width] [-palette] [-transparent] [-demo]. OPTIONS (No arguments) : Displays this text. -help/-h : Same as above if it is the first argument. FILENAME : If the name of the file is the only argument, the original image will be analyzed to see if conversion is possible and in that case which options that are possible. -image|-tiles|-sprites : Set conversion mode (mandatory). When image mode is used the original image must be either 320 or 640 pixels wide. -height/-h : Set height of tiles or sprites (not used when converting to a bitmap image). Valid values for tile mode are 8 and 16, for sprites 8, 16, 32 and 64. -width/-w : Set width of tiles or sprites, (not used when converting to a bitmap image). Valid values are the same as for height. -palette/-p : Set file format for the destination file that contains the palette. Valid values are: bin - a binary file asm - text file containing assembly source code) bas - text file containing BASIC DATA statements). If this option is omitted, all three files will be created. -transparent/-t : Set which color that will have index 0 in the generated palette. The value must be a 32-bit hexadecimal value in the following format: $aarrggbb where a = alpha, r = red, g = green and b = blue. -demo/-d : Generate a demo program in BASIC. This can be loaded to the emulator by using the -bas option. For example: x16emu -bas mysprites_demo.txt. To run it immediately add the option -run. Using this option will cause a binary palette file to be created. EXAMPLES X16PngConverter : Display help text. X16PngConverter image.png : Analyse image and see if it is possible to convert. X16PngConverter image.png -image : Convert to a bitmap image (width must be 320 or 640 pixels). X16PngConverter image.png -tiles -h 16 -w 16 : Convert to tiles with a widht and height of 16 pixels. X16PngConverter image.png -image -p asm : Convert to sprites and output palette only as a file with assembly source code. X16PngConverter image.png -image -t $ff88aacc : Convert image with the specified (potentially transparent) color as the first in the generated palette. X16PngConverter image.png -image -demo : Convert image and generate a BASIC demo program named image_demo.txt.
    1 point
  41. Version 1.0.0


    Commander X16 Sprite Editor This is a screen snapshot and the executable file of a Commander X16 Sprite Editor which is built from "C" source files I’ve been developing that currently runs on Release 37 of the emulator. Features The sprite editor supports all combinations of sprite height and width dimensions up to 64x64. The sprite editor is currently limited to 4 color bits per pixel, but provides the ability to edit the RGB values of the first 16 entries of the color palette. The sprite editor supports a pen mode which reduces the keystrokes required to assign colors to sprite pixels, and the ability to shift the design of the sprite to make more room near the edge of the sprite. The sprite editor provides the ability to export color palette data as well as sprite data to the terminal in a BASIC program format and also in a format more amenable to importing into a C program. The BASIC program allows the sprite to be rendered and moved around a bit using the W/A/S/D keys. This export capability requires the -echo option when starting the emulator. Operation Cursor Movement The arrow keys are used to move the cursor around the sprite pixel edit grid. When width=64 the edit grid can be paged left and right using the less-than and greater-than keys ("<" and ">"), and when height=64 the edit grid can be paged up and down using the comma and period keys ("," and "."). Assigning Colors to Sprite Pixels The 0-9/A-F keys are used to assign a color to the sprite bit corresponding to the current edit grid cursor position. When pen mode is turned on using the P key, the color at the current edit grid cursor position is assigned to the pen, and this color is automatically assigned to pixels as the edit cursor is moved. The pen color can be changed by selecting a new color via the 0-9/A-F keys. Pen mode is manually turned off by pressing the P key a second time, and is automatically turned off when the cursor is moved past the edge of the edit grid and when the edit grid is paged when height=64 or width=64. The fill command (F5 key) fills the entire sprite with the color at the current edit grid cursor position. RGB Edit Mode RGB edit mode provides the ability to edit the RGB values of the first 16 entries of the color palette. RGB edit mode is entered and exited by pressing the F6 key. In RGB edit mode, a right arrow appears to the left of the selected color, and selected color is changed by using the up/down cursor keys. The red, green, and blue components of the selected color are changed by using the R/shift-R, G/shift-G, and B/shift-B keys. Sprite Design Shifting The sprite design can be shifted up or down one pixel row using the U and shift-U keys, and can be shifted right or left one pixel column using the R and shift-R keys. This feature is useful when a sprite design is not centered correctly when started and one runs out of space near an edge. The sprite design can be shifted to make more room near the edge which avoids having to start the sprite design over again at a new location. Sprite Options V-flip and H-flip (V and H keys) affect the display of the actual sprite but not the sprite edit grid. The palette offset (+/- keys) also only affects the display of the actual sprite (the edit grid colors and remainder of the screen colors are not affected). Screen Options The BG and FG options (F3 and F4 keys) provide the ability to change the screen background color and the color of the text on the screen. There's an anomaly associated with color 0 which is black in the standard color palette. Color 0 is shown as black on the screen and edit grid but is transparent when used in sprites, so the edit grid doesn't match the sprite with respect to color 0. Exported BASIC Program The exported BASIC program between line 10 and the DATA statements is constant. Line 10 varies with the height and width of the sprite and the DATA statements vary with the color palette data and design of the sprite. The SA7 value is based on the enumerated values of the height and width dimensions (0 for 8, 1 for 16, 2 for 32, and 3 for 64) and places these values into the proper position to be populated in the most significant nibble of the last sprite attribute register which has an offset of 7. The least significant nibble of this register is the palette offset which I assumed to be 0. The SA7 value is computed in the C program, but it could have been computed in the BASIC program since the enumerated values can be determined from the height and width which are exported on line 10 and palette offset is assumed to be 0. I deferred support for saving/loading palette and sprite data because I'm under the impression the emulator currently doesn't support file I/O, but the BASIC program provides a near-term workaround. The palette and sprite data exported in the BASIC program format can be reloaded into the sprite editor via the following steps: (1) start the emulator using the -echo option; (2) paste the BASIC program into the emulator; (3) execute the RUN command; (4) push the Esc key to quit the running program; (5) execute the NEW command; (6) load the sprite editor; and (7) execute the RUN command. The sprite editor will then pick up the palette data that was loaded into the color palette and sprite data that was loaded into the VERA sprite attribute registers and VRAM by the BASIC program. The following two steps are an alternative to step (2) above: (2a) paste the BASIC program into a text file; and (2b) use the emulator -bas option to load the program from the text file when starting the emulator. This alternative approach is recommended if you're having problems with the emulator corrupting lines when pasting the BASIC program directly into the emulator. The palette and sprite data are automatically exported when exiting the sprite editor to avoid accidental loss of data. The exported data can be recovered before reloading and restarting the sprite editor as described above. Potential Future Enhancements I'm considering enhancements including support for 8 color bits per pixel, saving/loading of palette and sprite data, rotation of sprites, and undo/redo of changes to the sprite graphics data in VRAM.
    1 point
  42. Version 0.5


    I had been lurking on the forums for a few months when I found Prog8 and though this looked interesting. I.e. I could learn a new language and test out the emulator. I recently saw some good demos using C64 emulator but just based on PETSCII graphics and I though this looked surprisingly cool. Then I remembered the old Galaga game on the C64, the one using just (a few) petscii chars. I thought making something similar would be a nice challenge. The game is continuing to move toward what I consider a complete (but short) game. There are now 12 levels at which point the game will end in victory (bonus points for lives remaning). I am currently inclined to thinking that it's ok to end up with a fairly short and "completable" game. I still need to add some sort of simple high score handling. And there are always places that could use a bit of extra polishing but perhaps it would be better to spend that effort on another game. If anyone want to have a look at the code, it's here : https://github.com/cyborgar/Petaxian
    1 point
  43. Version 0.1.1


    Version 0.1 This software converts indexed and RGBA images in the formats PNG, JPG or GIF into binary data suitable for the VERA chip in the upcoming 8-Bit Computer Commander X16. Basic usage: Open an image file using File/Open... Configure the settings according to your needs. Export the image using File/Export Bitmap/Tiles/Sprites... Image Modes: You can open either an indexed image with an embedded palette or a regular RGBA image. Depending on the image mode, the software behaves slightly differently. RGBA: In RGBA mode, VGC needs to match the pixel colors to the colors in the palette. This can be done by comparing color similarity in RGB (Red, Green, Blue), HSL (Hue, Saturation, Lightness) or HSV (Hue, Saturation, Brightness) mode. Select the conversion strategy that works best for your image. Ideally load a palette that matches all colors in the image. You can specify the bit depth of the image by changing the pixel mode. 1 Bit per Pixel results in 2 colors, 2 Bits per Pixel result in 4 colors, 4 Bits per Pixel result in 16 colors and 8 Bits per Pixel uses the whole palette of 256 colors. The colors usable by the image depend on the palette offset. Indexed: In indexed mode VGC assumes that all pixels in the image have the correct index. It is still necessary to select the correct palette offset to give a correct export. On export the palette offset is subtracted and the index value capped on the selected pixel mode. Transparency Any pixel in the image that has an alpha value of 255 is set to the index selected in "Transparent Color Index". The minimum value is the palette offset. Image Mode: The VERA Graphic chip has three modes. Bitmap, tiled with a tile dimension of 8 * 8 pixels and tiled with a tile dimension of 16 * 16 pixels. Both tile modes split the image in separate tiles and limit their number to 256, since the VERA chip cannot address more than 256 tiles. It is also possible to limit their number even further. To use a tile mode the width and height of your image must be divisible by 8 or 16. The VERA chips supports 4 different resolutions: 640x480, 320x480, 640x240 and 320x240. VGC does not enforce these resolutions. It is also possible to generate sprite maps. In sprite mode the tiles can have 8, 16, 32 or 64 pixels in width or height. They are however limited to 128 tiles, and similarly, the source images dimensions have to be divisible by the tile dimensions. Sprites can only have a color depth of 4 or 8 Bits per Pixel. PRG File Header It is possible to save the exported binary file with 2 leading bytes. This is necessary for some load routines in the Commander X16 Kernal. Splitting files The exported files can be saved in chunks of a given size. The VERA Video RAM is paged in pages of 2048 bytes. Files can be split at any page, depending on how you want to store or load your data. The PRG File Header is saved to every individual file. The Palette You can load and save the color palette in the Format used by the Gnu Image Manipulation Program (GIMP) Other software like Aseprite can read and save this format too. You can also export the palette in the format used by the VERA chip. The PRG Header option is applied to this as well. The file splitting is not. Analyzing the image. You can double click on colors in the palette to change them. When you hold the left mouse button on a color in the palette, the parts of the image using this color are highlighted. Similarly, when you click on the image the color in the palette is also highlighted.
    1 point
  44. Version 0.4


    BASIC PREPROCESSOR allows one to create Commodore BASIC programs with a normal text editor without line numbers. Features: Much as strings begin and end with a quotation mark ("), macro constructs begin and end with a commercial at sign (@). This means that you cannot include @ in a macro, but otherwise any character may be used. A label can be defined on a line by itself as @+LABEL@. A label can be referenced after a GOTO or GOSUB as @-LABEL@ (including ON statements). A long variable name can be used as @!NAME@. A preprocessed comment can be used as @' whatever text you want @. These comments are not written to the PRG file. Any leading whitespace on a line is removed before writing the code to the PRG file. The preprocessor (probably) requires an emulator built from the master github branch. The program is written almost completely in BASIC. The one exception has to do with tokenization. Normally as you enter lines of BASIC the computer will translate them into a compressed tokenized form, and this is necessary for the programs to be usable. In order for BPP.PRG to create tokenized BASIC programs, it has a small machine language routine in golden RAM that converts from plain text to tokenized form. The tokenized form is written to the output PRG file. Here is a super simple example called SIMPLE.BPP. An animated GIF demonstrates the process of using the program.
    1 point
  45. Version 1.0.1


    At last!! The possibility to do pset Just started with Commander X16 emulator today and it brings back a lot of good memories from my time with my old "bread box". I did a similar program on my old C64 back in the days but I can't remember all the POKEs and PEEKs necessary to do this in BASIC on the Commodore 64, but with this machine it's actually possible in just a few lines.
    1 point
  46. Version 1.0.0


    Another small intro. Sadly still no audio. If only it wasn't so painful to debug audio and if I had any sort of musical talent... Thanks for looking! Spinner.zip
    1 point
  47. Version 1.0.0


    This is simply a single-octave piano that lets you select up to 4 waveforms to play simultaneously at the same frequency, at any chromatic note in the octave starting at Middle C. All controls are illustrated on the screen, with the number keys acting as toggles. Waveforms highlighted red will be played at full volume for any note. Code is available in the Lesson13 subdirectory of this GitHub repo: https://github.com/SlithyMatt/x16-assembly-tutorial You can see a demo of this program (along with a lesson on how use the VERA PSG with assembly language) on YouTube: If you are a member of my Patreon community (https://www.patreon.com/slithymatt) , you'll also have exclusive access to a video in which I give a complete code walkthrough for this Piano program.
    1 point
  48. Version 0.0.0


    I've since removed the external file dependencies for building the UI which means folks can finally try Command Tracker out more directly in the emulator. A very basic song exists to start. There is no loading and saving yet and, as noted in the dev log on the forums, it's buggy and, as of yet, no real sound engine (rather a very very basic one) but it does work and demonstrates what I'm trying to work towards in a full featured tracker. It is modeled loosely after Impulse Tracker on PC.
    1 point
  49. Version 1.0.0


    I wrote a library to enable BASIC programs play music in the background. It is compatible with Simplest Effects Sound library I released a while ago. To demo the library I included two BASIC programs: PLAY.BAS - Playing Twinkle Twinkle Little Star - it demonstrates the BASIC program doing other stuff including calling simple Effects HOUSE.BAS - Playing House of the Rising Sun - it demonstrates a bit more complex music Full Tutorial and source code is available from my blog: https://www.8bitcoding.com/p/music-player-library-for-basic-programs.html
    1 point
  50. Version 1.1.0


    These files are two javascript extensions for the Tiled Map Editor. They allow you to export your map either as assembler source code (ACME syntax) or in a raw binary format including a two byte header set to 0. They support flipping of tiles and let you select a palette offset. If you are using another assembler the first extension can easily be changed for your needs if you have som basic knowledge of javascript : ). Installation is done by simply placing the files in the extension folder of Tiled. It will then immediately be read and installed if Tiled is running. Windows C:/Users/<USER>/AppData/Local/Tiled/extensions/ macOS ~/Library/Preferences/Tiled/extensions/ Linux ~/.config/tiled/extensions/ For more information about extensions, see the official documentation: https://doc.mapeditor.org/en/stable/reference/scripting/
    1 point
  • Create New...

Important Information

Please review our Terms of Use