Workprint – December 2018

Time for another workprint and I’m afraid this one is pretty much going to be a case of me saying “watch this space” in various different ways because, whilst there are things ongoing for amongst other things the CSDb Intro Creation Competition, I’m keeping the entire deck of cards close to my chest for the moment to allow for random rewrites or complete changes of project priority. There are at least two more intros being prodded at right now and one uses an FLD routine, but that’s about as specific as I’m willing to get for the moment.

But one of the sillier ideas I came up with a few weeks back but ultimately decided not to pursue – one of the down sides to the CSDb ICC is that you can only enter three intros, I usually have twice as many ideas – was by total coincidence realised by ROLE a few days back, although my version was going to be a bit more involved technically, pushing into the side borders and stretching the sprite. Perhaps I’ll do my interpretation and release it alongside the competition if I can find some free time?

There’s going to be a couple of releases on t’other label now that December is under way; it’s game code that’s been loitering around my hard disks for an age that was essentially put aside but not quite forgotten entirely when I switched to “demo mode”. You could consider those to be a “festive season bonus” but, since I dislike said annual event with a passion and am nowhere near organised enough to arrange something like that anyway, it’s really just me “clearing the decks.

Workprint – December 2017

Keeping with my “schedule”, it’s the first Friday of the month and time for a quick update… and yes, I’m as surprised as everybody else that this turned up on time!

Rubidius is slowly taking shape, it completed its first proper loop – going titles page to game and back with or without passing through the completion screen with the presentation stuff mostly being placeholder code – yesterday and I’ve got the score counter in and a test version of the music Andy is working on playing in the background. There’s nothing new to show right now because it doesn’t look much different to the previous screenshot, but some proper level graphics have been started and, once I get a certain writing deadline out of the way, I hope to find a few days to draw and install some actual backgrounds.

There has also been some pondering over the idea of writing a C64 game for C64CD in part as a demonstration of how easy it actually is; since scrolling shoot ’em ups are my default state it’ll almost certainly be one of those, but trying to keep things as simple as possible to the point it’ll essentially be a more primitive but tile-based version of Warflame. I have a few interesting ideas about “features” and the thought of publishing it in some form is amusing (to parody a certain person’s suggestion of Kickstarting a book based on his blog) but most of those options still need feasibility tests and bespoke code. This might also end up as the final resting place for the tiles that’ll soon be pulled from Rubidius as well.

How Koalatro works

There were some interesting responses to Koalatro over at the CSDb when it was released, with a few people expressing surprise that the code only takes 16K which has left me giggling like a schoolgirl because, apart from some zero page use which doesn’t count towards the total according to the competition rules, the entire thing runs from 15K, loading and executing between $0400 and $3fff. A Koala-format bitmap is 10,001 bytes (8,000 of bitmap, 2,000 of colour and a byte for the background colour register), aNdy’s music takes around 3K and another half a K is taken up by unrolled code to open the borders and split sprite colours. So that’s about 13.5K use and the rest of the code, some tables, sprite definitions and a little scroll text therefore have to fit in the remaining 1.5K… right?

Well not exactly and it’s probably best to look at the memory map in order to explain further; before the code starts, the layout looks like this:

$0400 - $07e7	First block of colour RAM for the bitmap
$07e8 - $09db	Second block of colour RAM for the bitmap (packed)
$09dc		Background colour register
$0a00 - $13ff	Code, data and scroll text
$1400 - $1fff	Music
$2000 - $3f3f	Bitmap data
$3f40 - $3fff	Colour tables and sprite positioning/set-up data

The first two “tricks” are how colour for the bitmap has been stored; the first block at $0400 is already where it needs to be (which is why only the crunched file from the Github repository can be dragged and dropped into an emulator) so there’s no memory lost elsewhere or code required to move it into place. The second block of colour is a bit more involved since it’s been packed down into 50% of the RAM; this relies on the fact that only the lower nybble is used (a value from $0 to $f) so two of those can be stored in one byte. The background colour byte from the Koalapainter format file is included for completeness and the code will actually deal with other background colours cleanly despite that not being required in the final release.

One thing that’s missing from the memory map above is where the sprite definitions for the scroller are being stored but there’s a small hole between the end of the packed colour data and where the code starts for a reason; one of the first things the code does is unpack the colour data to $d800 and, once that’s done, the space from $0800 to $09ff is then cleared and used for the sprites so there’s only eight definitions available but, since both scrollers use the same eight sprites, that’s not an issue.

And speaking of the scrollers, there’s that block of unrolled block of code I mentioned previously to split the sprite colours and yes, it’s literally doing that; rather than changing the background colour and having black sprites over the top it’s actually writing one of two values to every sprite colour register on each scanline whilst juggling $d016 to open the side borders. The same block of unrolled code is recycled for the two scrollers, starting one scanline further up the sprites for the upper area so the reversed version of the scrolling message gets the static colours. Finally there’s the eight hundred bytes of scroll text from $10de to $13fe which leaves one byte free before the music starts.

I think that’s everything of note covered, the source code is, I hope, reasonably well documented.