Kla2kick

Convert KoalaPainter files to KickAssembler ASM files. Tool built as the final stage in an integration pipeline. Most C64 graphics tools output to KLA, but that format is unwieldy to use from Assembler. Converting into sequences of bytes that KickAssembler can read permits me to put the graphics in PRG files and put them into cartridge memory banks.

It's impossible to know beforehand where in memory you'll want to assemble your bytes, so the KLA-file gets split into three parts. As an example image.kla would get converted into image_screen.asm, image_color.asm and image_bitmap.asm.

It's up to you to import these .asm files into your own code. You can use the KickAssembler #import for that.

Build instructions

Install Rust. Either through your machine's package management or have a look at https://rustup.sh for generic instructions. I'm assuming you have the cargo tool available.

From the project's cloned directory, run a production build:

cargo build --release

You'll have a binary in target/release/kla2kick that you can run.

Usage

Your input file must be a valid uncompressed KoalaPainter file. Kla2kick does NOT check for validity of the source file at all. In fact: whatever you feed it, as long as it ends in .kla, will get its bytes read and converted to byte-statement that you can use in KickAssembler. It'll most likely be complete garbage, but that's your own responsibility.

Assuming you're using it from a root directory with a graphics/ subdir, the invocation looks like this:

kla2kick graphics/picture.kla

The result will be three new files inside graphics/

• graphics/picture_bitmap.asm
• graphics/picture_screen.asm
• graphics/picture_color.asm

You can use an Assembly file in your root directory to load these fragments.

*=$0000
bitmap:
#import "graphics/picture_bitmap.asm"
screen:
#import "graphics/picture_screen.asm"
color:
#import "graphics/picture_color.asm"

..or do whatever else you want with your chunk of bytes.