I've got a question about what the best way to do the below is. I'm looking for a solution that returns the minimal number of bytes of code, rather than vast efficiency in code speed.

For the SAGA remake, I need to compress the rooms exits. The standard format is:

Where N, S, E, W, U, D are the room that going that direction will take you to (up to 150). A 0 indicates the direction is closed.

I've already compressed the description down, so I'm thinking that I can compress this data structure by having:

Where exits is a byte with a bit set for each location if there is an exit (e.g. bit 0 = N, bit 1 = S etc). And then a compacted list of exits for only those rooms that are open.

So I need two routines: one to count the number of exits; the other to match a given exit to the appropriate byte.

The first should be relatively easy, just using a loop like:

But the second one I can't even think of how to get started; I guess doing something similar to the above but actually increasing the pointer into the data would do?

Any ideas to improve it?

This is about as cunningly as I can do it:

It's not tested, but I think it ought to work! I think it's about as compact a routine as it can be.

Here's another approach which uses a lookup table to calculate 2^X and which looks simpler, but is in fact a whole 7 bytes longer in total.

Just noticed, you have a bug in this code:

The ROR A should be a LSR A (because ROR shifts the carry flag into bit 7, but it is undefined each time round the loop). Also, you can save a byte by using BCS loop instead of JMP loop!

Ah the joys of typing code out and not trying it out

I actually thought ROR would be okay as I didn't care about the contents of the high bits (as I only do 8 shifts). It's also because I couldn't remember what the mnemonic was to do the right version of ASL

I like your logic with replacing the JMP with a BCS (as I now know that INC/INY/INX doesn't affect carry - that stumped me for ages).

I'll give your routines a try. Thanks.

Whilst we're on the subject of code improvement. I find I'm doing a lot of manipulation of 16-bit pointers, all following the standard code of:

Is this the best way to do it; any suggested improvements?

Actually, yes it's true - in this case it will work fine as you don't care about what gets rotated in to the high bit. But, in general, if you don't know the state of the carry flag, a LSR is better


In this case, you can normally change the JMP to either a BNE or a BPL, assuming that the address is never going to end up greater than &8000, or in the zero page.

But yeah, there's not really any other way of adding an 8 bit number to a 16 bit one - you have to go through all that each time. As I mentioned somewhere else, you might win back space if you were to make a subroutine which added A to ptr (for example).

Also you can occasionally save a CLC if you know the state of the carry flag in advance. If C is set, then:
is equivalent to:

And of course forgetting to do a CLC before an ADC may cause odd results at "random" times; as I found out about 2 hours ago!